crm之搭建框架

CRM（Customer Relationship Management）就是客户关系管理

具体是干什么的 本人就不解释啦 百度上有~~

第一步: 创建一个web项目

MyCrm

第二步:导入jar包 相应的jarN多在这就不多说啦 

这个项目是s2sh 记得吧这些包都导进来啊

第三步:数据库先整一下

怕接受不拉 还是先整一个部门表把 一步一步来 千万不要偟

create database CRM  charset utf8;

#部门信息表
CREATE TABLE `sys_user_group` (
`id` INTEGER(11) NOT NULL AUTO_INCREMENT, #编号
`remark` TEXT, #备注
`name` VARCHAR(100) DEFAULT NULL, #部门名称
`principal` VARCHAR(50) DEFAULT NULL, #部门负责人
`incumbent` VARCHAR(200) DEFAULT NULL, #部门职能
PRIMARY KEY (`id`)
)

第四步:开始开发 还是从新细分 怕乱~~

-------------------------------------------------------------------------------------------------------

(一)hibernate 打通

第一步 创建 com.crm.domain包

创建SysUserGroup类

package com.crm.domain;
/**
* 部门表的po对象
*/
public class SysUserGroup {
private Integer id;
private String remark; //备注
private String name; //部门名称
private String principal; //部门负责人
private String incumbent; //部门职能
为啦节省地方 set get 还有构造就不写啦 以后的vo也不写啦 原谅一下.

第二步:让hibernate 认识您这个类啊

创建SysUserGrop.hbm.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.crm.domain.SysUserGroup" table="sys_user_group">
<id name="id" type="integer">
<column name="id" />
<generator class="identity"></generator>
</id>
<property name="name" type="string">
<column name="name" sql-type="varchar(20)"></column>
</property>
<property name="remark" type="string">
<column name="remark" sql-type="varchar(20)"></column>
</property>
<property name="principal" type="string">
<column name="principal" sql-type="varchar(20)"></column>
</property>
<property name="incumbent" type="string">
<column name="incumbent" sql-type="varchar(200)"></column>
</property>
</class>
</hibernate-mapping>

第三步:在src创建一个hibernate.cfg.xml 不解释 代码如下

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="hibernate.connection.url"><![CDATA[jdbc:mysql://127.0.0.1:3306/CRM?useUnicode=true&characterEncoding=UTF-8]]></property>
<property name="hibernate.connection.driver_class">
com.mysql.jdbc.Driver
</property>
<property name="hibernate.connection.autocommit">true</property>
<property name="hibernate.dialect">
org.hibernate.dialect.MySQL5Dialect
</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<property name="hibernate.show_sql">true</property>
<mapping resource="com/crm/domain/SysUserGroup.hbm.xml" />
</session-factory>
</hibernate-configuration>

第四步:当然就是测试啦 不作单元测试 的程序就是垃圾~~(我老师说的 不是我说的啊 ~~~)

public class TestHibernate {
/**
* 测试hibernate是否打通
*/
@Test
public void testHibernateConf(){
Configuration configuration=new Configuration();
configuration.configure(); //从src目录下加载配置文件hibernate.cfg.xml文件
SessionFactory sessionFactory=configuration.buildSessionFactory(); //从hibernate.cfg.xml文件中sessionFactory节点中获得sessionFactory
Session session=sessionFactory.openSession(); //通过sessionFactory中的opernsession获得一个session对象
Transaction transaction=session.beginTransaction(); //通过session打开一个事物
SysUserGroup sysUserGroup=new SysUserGroup();
sysUserGroup.setName("销售部");
sysUserGroup.setPrincipal("杨天赐");
sysUserGroup.setIncumbent("销售产品");
sysUserGroup.setRemark("很有钱途的职业");
session.save(sysUserGroup); //保存对象到数据库
transaction.commit(); //提交
session.close();
}
}

如果看到数据库里面插入数据恭喜你 hibernate通啦

-------------------------------------------------------------------------------------------------------------------------------------

(二)spring 打通

第一步:当然的创建一个beans.xml文件啦

代码如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<!-- 1 配置注解自動掃描 -->
<context:component-scan base-package="com.crm" />
<!-- 2 暂时不写 -->
<!-- 3 配置本地化代理工程bean,这个是spring整合hibernate的入口 -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
<!-- 4 创建事物管理器 aop切面 -->
<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!-- 5 配置处理事物的注解 -->
<tx:annotation-driven transaction-manager="txManager"/>
</beans>

第二步:这个也不好测试一下 还是开始整dao 层 在dao层整好以后 一起整怎么样(不管你同意不同意 我就这么整啦你能怎么我~~~)

-------------------------------------------------------------------------------------------------------------------

(二.2)dao层开发

真正的高手是什么样子的 以前我不知道 不过 冯老师让我见识到啦 真正的生命叫java 什么叫面向接口编程 什么叫代码的重用性.. 什么叫可扩展,什么叫高内聚弱耦合 不说啦 代码说话...

因为 想最基本的不就是CRUD吗 抽象一个公共(common)接口 和类 后面的 只需实现和继承即可 里面方法体不用写任何代码

第一步:ICommonDao开发 位于com.crm.dao 下

/**
*
* 创建一个共同的接口
*
* @param <T>
* 通过泛型来注入实例的对象
*/
public interface ICommonDao<T> {
public void save(T entity);

public void update(T entity);

public T findObjectById(Serializable id);

public void deleteByIds(Serializable... ids);

public void deleteAllObjects(Collection<T> entities);

public List<T> findObjectsByConditionWithNoPage(String whereHql,
Object[] params, LinkedHashMap<String, String> orderby);
}

第二步:创建CommonDaoImpl  位于com.crm.dao.impl下 代码如下 (有点多有点乱~~ 如果有心的人看到多多研究 不懂问我(QQ 1007387220))

/**
*
* 继承hibernateDaoSupport类 并且注入sessionFactory
*
* @param <T>
*/
public class CommonDaoImpl<T> extends HibernateDaoSupport implements
ICommonDao<T> {
private Class entityClass = GenericClass.getGenericClass(this.getClass());

/**
* 通过hibernateDaoSupport中的hibernateTemplate模板可以保存对象
*/
public void save(T entity) {
this.getHibernateTemplate().save(entity);
}

/**
* 因为在父类中被设置成啦final类型 所以不能覆盖但是可以从新写个方法 通过super关键在来注入 但外部的dao继承此类是
* 只需注入sessionFactory即可
*/
@Resource(name = "sessionFactory")
public void setSessionFactoryDI(SessionFactory sessionFactory) {
super.setSessionFactory(sessionFactory);
}

public void update(T entity) {
System.err.println("我看进入这里啦吗");
this.getHibernateTemplate().update(entity);
}

/**
* 通过id来查找一个对象
*/
public T findObjectById(Serializable id) {
/**
* 这里需要获得类 可是 我们在这次传递是泛型没有类怎么班那? 通过一个类来获得泛型的类啊
*
*/
if (id == null) {
throw new RuntimeException("您要查找的[" + id + "]不能为空");
}
return (T) this.getHibernateTemplate().get(entityClass, id);
}

/**
* 通过id.. 来删除
*/
public void deleteByIds(Serializable... ids) {
if (ids != null && ids.length > 0) {
for (Serializable id : ids) {
Object entity = this.getHibernateTemplate()
.get(entityClass, id);
if (entity == null) {
throw new RuntimeException("您查找的这个[" + id + "]不存在");
}
this.getHibernateTemplate().delete(entity);
}
}
}

/**
* 通过一个集合来删除 这个集合也就代表对象
*/
public void deleteAllObjects(Collection<T> entities) {
this.getHibernateTemplate().deleteAll(entities);

}

/**
* 返回一个集合 开始拼接hql语句
*/
public List<T> findObjectsByConditionWithNoPage(String whereHql,
final Object[] params, LinkedHashMap<String, String> orderby) {
// 第一: sql 语句为SELECT * FROM SysUserGroup o WHERE
String hql = "select o from " + entityClass.getSimpleName()
+ " o where 1=1";
// 第二: 在where后面动态的添加条件(这一步在service中处理 因为页面传过来的不同)
if (StringUtils.isNotBlank(whereHql)) {
hql = hql + whereHql;
}
// 第三最终极hql 要变成final 在内部类中进行处理
final String fhql = hql;
// 处理排序 order by o.name asc ,o.age desc
String orderbystr = buildOrder(orderby);
hql = hql + orderbystr;
// 通过hibernatetemplate模板中execution(hql)来返回list
List<T> list = (List<T>) this.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session paramSession)
throws HibernateException, SQLException {
Query query = paramSession.createQuery(fhql);
setParams(query, params);
return query.list();
}

});
return list;
}

/**
* 设置hql语句传递过来的参数
*
* @param query
* @param params
*/
public void setParams(Query query, Object[] params) {
if (params != null && params.length > 0) {
for (int i = 0; i < params.length; i++) {
query.setParameter(i, params[i]);
}
}
}

/**
* 为什么要用map那? 从外面传过来 在这里拆分一下 然后动态组装就OK order.put("o.id","asc");
* order.put("o.name","desc"); order.put("o.age","asc");
*
* @param orderby
* @return
*/
private String buildOrder(LinkedHashMap<String, String> orderby) {
StringBuffer buf = new StringBuffer("");
if (orderby != null && orderby.isEmpty()) {
buf.append(" order by "); // 这部一定不要忘记啊
for (Map.Entry<String, String> me : orderby.entrySet()) {
buf.append(me.getKey() + " " + me.getValue() + ",");
}
buf.deleteCharAt(buf.length() - 1);// 去掉最后一个的","号
}
return buf.toString();
}
}

大家可能有点郁闷 写这么多代码还说 高手~~ 还说方法体不用写代码 牛b吹打了把  不解释 走着瞧~~

现在公共的搞定啦 开始创建单个的部门dao 和部门实现类把

第三步:创建SysUserGroupDao 部门dao 

public interface ISysUserGroupDao extends ICommonDao<SysUserGroup>{
/**
* 这个静态属性是方便注入用的 在这个接口中什么都不需要写..
*/
public final static String SERVICE_NAME="com.crm.dao.impl.SysUserGroupDaoImpl";
}

第四步:SysUserGroupDaoImpl

/**
* 在这个类中也是什么都不要写 只需要继承CommonDaoImpl即可
* 全部通用的方法全部在CommonDaoImp中实现 这个类只需要继承 不需要写任何方法体
*/
@Repository(ISysUserGroupDao.SERVICE_NAME)
public class SysUserGroupDaoImpl extends CommonDaoImpl<SysUserGroup> implements ISysUserGroupDao {
}

说来这么多开始测试一下dao增删改查 ..

/**
* 测试保存
*/
@Test
public void testSave() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"beans.xml");
ISysUserGroupDao sysUserGroupDao = (ISysUserGroupDao) applicationContext
.getBean(ISysUserGroupDao.SERVICE_NAME);

SysUserGroup sysUserGroup = new SysUserGroup();
sysUserGroup.setName("市場部");
sysUserGroup.setPrincipal("張鯤鵬");
sysUserGroup.setIncumbent("調研");
sysUserGroup.setRemark("很雙的职业");

sysUserGroupDao.save(sysUserGroup);
}
/**
* 测试更新
*/
@Test
public void testUpdate(){
ISysUserGroupDao sysUserGroupDao=(ISysUserGroupDao) ServiceProvinder.getService(ISysUserGroupDao.SERVICE_NAME);
SysUserGroup sysUserGroup=new SysUserGroup();
sysUserGroup.setId(2);
sysUserGroup.setName("市場部");
sysUserGroup.setPrincipal("田京辉");
sysUserGroup.setIncumbent("調研");
sysUserGroup.setRemark("很雙的职业");
sysUserGroupDao.update(sysUserGroup);
}
/**
* 通过id查找这个部门
*/
@Test
public void findSysUserGroupById(){
ISysUserGroupDao sysUserGroupDao=(ISysUserGroupDao) ServiceProvinder.getService(ISysUserGroupDao.SERVICE_NAME);
//在这里声明为Serializable 是为啦通用性..
Serializable id=1;
SysUserGroup sysUserGroup=sysUserGroupDao.findObjectById(id);
System.err.println(sysUserGroup.getName());

}
/**
* 删除一个或者多个
* 封装成一个数组ids
*/
@Test
public void deleteByIds(){
ISysUserGroupDao sysUserGroupDao=(ISysUserGroupDao) ServiceProvinder.getService(ISysUserGroupDao.SERVICE_NAME);
Serializable[] ids={4,5};
sysUserGroupDao.deleteByIds(ids);
}
/**
* 有时候有需求删除一个集合deleteCollections
*/
@Test
public void deleteCollections(){
ISysUserGroupDao sysUserGroupDao=(ISysUserGroupDao) ServiceProvinder.getService(ISysUserGroupDao.SERVICE_NAME);
List<SysUserGroup> list=new ArrayList<SysUserGroup>();
SysUserGroup s1 = new SysUserGroup();
s1.setId(12);
list.add(s1);
SysUserGroup s2 = new SysUserGroup();
s2.setId(13);
list.add(s2);
sysUserGroupDao.deleteAllObjects(list);
 }
}

如果你都能搞定 这就代码打通啦spring

----------------------------------------------------------------------------

(三)打通页面 struts2 这里采用与spring分离的方式整.. 避免过度的依赖..

不多说代码整~~

在打通页面之前 顺便把服务层也整一下把 

第一步创建SysUserGroupService

public interface ISysUserGroupService {
public final static String SERVICE_NAME="com.crm.service.impl.SysUserGroupServiceImpl";
public void saveSysUserGroup(SysUserGroup sysUserGroup);
public List<SysUserGroup> findSysUserGroups(String name, String principal);
}

第二步:创建 SysUserGroupServiceImpl 这里用到很多花招 用心的人捉摸一下 为什么要再service层来组织hql而不是在dao(不管你们知道不知道,反正我知道啦~~)

@Service(ISysUserGroupService.SERVICE_NAME)
@Transactional(readOnly = true)
public class SysUserGroupServiceImpl implements ISysUserGroupService {
@Resource(name = ISysUserGroupDao.SERVICE_NAME)
private ISysUserGroupDao sysUserGroupDao;

@Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED,readOnly=false)
public void saveSysUserGroup(SysUserGroup sysUserGroup) {
this.sysUserGroupDao.save(sysUserGroup);
}

public List<SysUserGroup> findSysUserGroups(String name, String principal) {
/**
* 为了不打扰上层 先模拟一下页面调用啦它
* 假如页面传过来的是 name=销售部 principal=杨天赐
* sql语句应该是这样的吧
* SELECT * FROM sys_user_group o WHERE o.name LIKE '%销售部%' AND o.principal='杨天赐' ORDER BY o.id
* hql为(一般服务层不能出来sql语句 但是可以出现hql语句)
* SELECT * FROM SysUserGroup o WHERE o.name LIKE '%销售部%' AND o.principal='杨天赐'
ORDER BY o.id asc,o.name desc
*/
//第一步组织Hql语句
String whereHql="";
//把从页面传过来的条件进行封装
List paramsList=new ArrayList();
if(StringUtils.isNotBlank(name)){
whereHql=" and o.name like ?";
paramsList.add("%"+name+"%");
}
if(StringUtils.isNotBlank(principal)){
whereHql=whereHql+" and o.principal = ?";
paramsList.add(principal);
}
Object [] params=paramsList.toArray();
//第二步: 组织排序
LinkedHashMap<String,String> orderby=new LinkedHashMap<String, String>();
orderby.put("o.id","asc");//到以后这个也是动态变化的 现在为了..先这样写
orderby.put("o.name", "desc");
List<SysUserGroup> list=sysUserGroupDao.findObjectsByConditionWithNoPage(whereHql, params, orderby);
return list;
}
}

好啦 还是测试一下把 怕~~ 冯老师说我不专业~~

public class TestSysUserGroupService {
@Test
public void testSave() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"beans.xml");
ISysUserGroupService sysUserGroupService = (ISysUserGroupService) applicationContext
.getBean(ISysUserGroupService.SERVICE_NAME);
SysUserGroup sysUserGroup = new SysUserGroup();
sysUserGroup.setName("人力资源部");
sysUserGroup.setPrincipal("張保佳");
sysUserGroup.setIncumbent("负责人事");
sysUserGroup.setRemark("很清闲的职业");
sysUserGroupService.saveSysUserGroup(sysUserGroup);
}

@Test
public void findObjectsByConditionWithNoPage() {
ISysUserGroupService sysUserGroupService = (ISysUserGroupService) ServiceProvinder
.getService(ISysUserGroupService.SERVICE_NAME);

// 获取部门名称
String name = "销售部";

// 获取部门负责人
String principal = "杨天赐";

@SuppressWarnings("unused")
List<SysUserGroup> list = sysUserGroupService.findSysUserGroups(name,
principal);
System.err.println(list);
/*
* 搞定 select sysusergro0_.id as id0_, sysusergro0_.name as name0_,
* sysusergro0_.remark as remark0_, sysusergro0_.principal as
* principal0_, sysusergro0_.incumbent as incumbent0_ from
* sys_user_group sysusergro0_ where 1=1 and (sysusergro0_.name like ?)
* and sysusergro0_.principal=?
  */
}
}

--------------------------------------------------------------------------

好啦 开始整action com.crm.web.action

第一步: 创建 SysUserGroupAction

public class SysUserGroupAction extends ActionSupport implements ModelDriven<SysUserGroupForm>{
private SysUserGroupForm sysUserGroupForm=new SysUserGroupForm();
public String save(){
System.out.println("sysUserGroupForm.getName() "+sysUserGroupForm.getName());

//实例化po对象
SysUserGroup sysUserGroup=new SysUserGroup();

//赋值vo对象的值到po中
BeanUtils.copyProperties(sysUserGroupForm, sysUserGroup);

//获取业务层的对象(本项目struts2和spring是分离的)
ISysUserGroupService sysUserGroupService = (ISysUserGroupService) ServiceProvinder.getService(ISysUserGroupService.SERVICE_NAME);
//调用业务层保存po对象
sysUserGroupService.saveSysUserGroup(sysUserGroup);
System.err.println("OVER....");
return null;
}
public SysUserGroupForm getModel() {
// TODO Auto-generated method stub
return this.sysUserGroupForm;
}
}

为啦让struts2认识还是整一个struts2.xml文件(在src下)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN"
"http://struts.apache.org/dtds/struts-2.1.7.dtd">
<struts>
<!-- 配置请求后缀名.do -->
<constant name="struts.action.extension" value="do"/>

<!-- 配置主题为简单主题 -->
<constant name="struts.ui.theme" value="simple"/>

<!--配置struts2的模式为开发模式-->
<constant name="struts.devMode" value="true"/>

<package name="sys" namespace="/sys" extends="struts-default">
<action name="sysUserGroupAction_*" class="com.crm.web.action.SysUserGroupAction" method="{1}">
<result name="add">/sys/group/add.jsp</result>
</action>
</package>
</struts>

第二部: 一定不要忘记在web.xml中配置过滤器啊~~

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<filter>
<filter-name>StrutsPrepareAndExecuteFilter</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>StrutsPrepareAndExecuteFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>

好啦 到底为之 strts2 打通啦 第一天也就over啦

--------------------------------------------------------------

杂碎总结一下 这里啰嗦一句

啰嗦一: 因为用的泛型 T 在里面怎么获得类那  就用到啦一个工具来 GenericClass

/**
*
*获得父类的类型
*clazz.getGenericSuperclass(); j就可用获得 一个ParameterizedType类型的类
*通过这个类的getActualTypeArguments()来获得它的真是的类型 不过这个方法返回的是个数组
*Class entityClass=(Class) type.getActualTypeArguments()[0];
*这个entityClass 就代表 父类的类型啦
*/
public class GenericClass {
public static Class getGenericClass(Class clazz){
ParameterizedType type=(ParameterizedType) clazz.getGenericSuperclass();
//type====com.crm.dao.impl.CommonDaoImpl<com.crm.domain.SysUserGroup>
Class entityClass=(Class) type.getActualTypeArguments()[0];
//entityClass===class com.crm.domain.SysUserGroup
return entityClass;
}
}

啰嗦二: 因为说要让struts2 和spring不要有过多的依赖怎么办 自己整个类 叫ServiceProvinder和ServiceProvinderCore类

public class ServiceProvinderCore {
protected ApplicationContext applicationContext;
/**
*
* @param fileName beans.xml
*/
public void load(String fileName){
applicationContext=new ClassPathXmlApplicationContext(fileName);
}
}

------------------------------------

public class ServiceProvinder {
private static ServiceProvinderCore serviceProvinderCore;
static{
System.err.println("加载啦ClassPathApplicationContext(beans.xml)");
serviceProvinderCore=new ServiceProvinderCore();
serviceProvinderCore.load("beans.xml");
}
public static Object getService(String beanName){
if(StringUtils.isBlank(beanName)){
throw new RuntimeException("您要访问的服务名称不能为空");
}
Object bean=null;
//如果spring容器中包含beanName
if(serviceProvinderCore.applicationContext.containsBean(beanName)){
System.err.println("加载啦applicationgetbean(SysUserDao)");
bean=serviceProvinderCore.applicationContext.getBean(beanName);
System.err.println(bean);
}
if(bean==null){
throw new RuntimeException("您要访问的服务名称["+beanName+"]不存在");
  }
return bean;
}

还是测试一下..

public class TestServiceProvinder {
@Test
 public void testProvinder() {
ISysUserGroupService sysUserGroupService = (ISysUserGroupService) ServiceProvinder.getService(ISysUserGroupService.SERVICE_NAME);
SysUserGroup sysUserGroup = new SysUserGroup();
sysUserGroup.setName("財務部");
sysUserGroup.setPrincipal("付小杰");
sysUserGroup.setIncumbent("负责財務");
sysUserGroup.setRemark("管錢的职业");
sysUserGroupService.saveSysUserGroup(sysUserGroup);
}
}

啰嗦三:还有一个问题 就是 vo和po的问题

package com.crm.web.form;
@SuppressWarnings("serial")
public class SysUserGroupForm implements java.io.Serializable{
private String id;
private String name;
private String remark;
private String principal;
private String incumbent;

vo 是页面的数据 po是数据库 在action中 通过copy 转移到 数据库中这样安全~~

第一天嘛 先试着把框架 打起来 后面以后慢慢整 crm这个项目挺大的 我也有很大鸭梨~~ 不过 天赐 加油~~ 没人给你打气 自己鼓励自己