基于SSH框架开发企业级CRM客户管理系统

分手后的思念是犯贱 2022-05-25 10:19 241阅读 0赞

**一.需求分析**

![70][]

**主UI：**

![70 1][]

**二.服务架构**

采用单服务架构，后期的博客会将该项目扩展到服务集群和分布式缓存系统架构，敬请期待。

![2018051222565149][]

**三.数据表设计**

部分E-R图：

![20180513211845364][]

用户表：

CREATE TABLE `sys_user` (
      `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id',
      `user_code` varchar(32) NOT NULL COMMENT '用户账号',
      `user_name` varchar(64) NOT NULL COMMENT '用户名称',
      `user_password` varchar(32) NOT NULL COMMENT '用户密码',
      `user_state` char(1) NOT NULL COMMENT '1:正常,0:暂停',
      PRIMARY KEY (`user_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

客户表：

CREATE TABLE `cst_linkman` (
      `lkm_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '联系人编号(主键)',
      `lkm_name` varchar(16) DEFAULT NULL COMMENT '联系人姓名',
      `lkm_cust_id` bigint(32) NOT NULL COMMENT '客户id',
      `lkm_gender` char(1) DEFAULT NULL COMMENT '联系人性别',
      `lkm_phone` varchar(16) DEFAULT NULL COMMENT '联系人办公电话',
      `lkm_mobile` varchar(16) DEFAULT NULL COMMENT '联系人手机',
      `lkm_email` varchar(64) DEFAULT NULL COMMENT '联系人邮箱',
      `lkm_qq` varchar(16) DEFAULT NULL COMMENT '联系人qq',
      `lkm_position` varchar(16) DEFAULT NULL COMMENT '联系人职位',
      `lkm_memo` varchar(512) DEFAULT NULL COMMENT '联系人备注',
      PRIMARY KEY (`lkm_id`),
      KEY `FK_cst_linkman_lkm_cust_id` (`lkm_cust_id`),
      CONSTRAINT `FK_cst_linkman_lkm_cust_id` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION
    ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

联系人表：

客户拜访记录表：

CREATE TABLE `sale_visit` (
      `visit_id` varchar(32) NOT NULL,
      `visit_cust_id` bigint(32) DEFAULT NULL COMMENT '客户id',
      `visit_user_id` bigint(32) DEFAULT NULL COMMENT '负责人id',
      `visit_time` date DEFAULT NULL COMMENT '拜访时间',
      `visit_interviewee` varchar(32) DEFAULT NULL COMMENT '被拜访人',
      `visit_addr` varchar(128) DEFAULT NULL COMMENT '拜访地点',
      `visit_detail` varchar(256) DEFAULT NULL COMMENT '拜访详情',
      `visit_nexttime` date DEFAULT NULL COMMENT '下次拜访时间',
      PRIMARY KEY (`visit_id`),
      KEY `FK_sale_visit_cust_id` (`visit_cust_id`),
      KEY `FK_sale_visit_user_id` (`visit_user_id`),
      CONSTRAINT `FK_sale_visit_cust_id` FOREIGN KEY (`visit_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
      CONSTRAINT `FK_sale_visit_user_id` FOREIGN KEY (`visit_user_id`) REFERENCES `sys_user` (`user_id`) ON DELETE NO ACTION ON UPDATE NO ACTION
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

客户信息表：

CREATE TABLE `cst_customer_detail` (
      `cust_id` bigint(32) NOT NULL,
      `cust_region` varchar(64) DEFAULT NULL COMMENT '客户地区',
      `cust_zip` varchar(16) DEFAULT NULL COMMENT '客户邮政编码',
      `cust_address` varchar(128) DEFAULT NULL COMMENT '客户联系地址',
      `cust_fax` varchar(64) DEFAULT NULL COMMENT '客户传真',
      `cust_website` varchar(128) DEFAULT NULL COMMENT '客户网址',
      `cust_licence` varchar(64) DEFAULT NULL COMMENT '客户营业执照注册号',
      `cust_corporation` varchar(64) DEFAULT NULL COMMENT '企业法人',
      `cust_capital` bigint(16) DEFAULT NULL COMMENT '客户注册资金',
      `cust_bank` varchar(512) DEFAULT NULL COMMENT '开户银行及账号',
      `cust_pic` varchar(64) DEFAULT NULL COMMENT '客户资质图片',
      `cust_memo` longtext COMMENT '客户简介',
      PRIMARY KEY (`cust_id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

数据字典表：

CREATE TABLE `base_dict` (
      `dict_id` varchar(32) NOT NULL COMMENT '数据字典id(主键)',
      `dict_type_code` varchar(10) NOT NULL COMMENT '数据字典类别代码',
      `dict_type_name` varchar(64) NOT NULL COMMENT '数据字典类别名称',
      `dict_item_name` varchar(64) NOT NULL COMMENT '数据字典项目名称',
      `dict_item_code` varchar(10) DEFAULT NULL COMMENT '数据字典项目(可为空)',
      `dict_sort` int(10) DEFAULT NULL COMMENT '排序字段',
      `dict_enable` char(1) NOT NULL COMMENT '1:使用 0:停用',
      `dict_memo` varchar(64) DEFAULT NULL COMMENT '备注',
      PRIMARY KEY (`dict_id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

用户角色表：

CREATE TABLE `sys_role` (
      `role_id` bigint(32) NOT NULL AUTO_INCREMENT,
      `role_name` varchar(32) NOT NULL COMMENT '角色名称',
      `role_memo` varchar(128) DEFAULT NULL COMMENT '备注',
      PRIMARY KEY (`role_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

CREATE TABLE `sys_user_role` (  
      `role_id` bigint(32) NOT NULL COMMENT '角色id',  
      `user_id` bigint(32) NOT NULL COMMENT '用户id',  
      PRIMARY KEY (`role_id`,`user_id`),  
      KEY `FK_user_role_user_id` (`user_id`),  
      CONSTRAINT `FK_user_role_role_id` FOREIGN KEY (`role_id`) REFERENCES `sys_role` (`role_id`) ON DELETE NO ACTION ON UPDATE NO ACTION,  
      CONSTRAINT `FK_user_role_user_id` FOREIGN KEY (`user_id`) REFERENCES `sys_user` (`user_id`) ON DELETE NO ACTION ON UPDATE NO ACTION  
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

**四.程序编写**

**4.1 项目引入Spring4, Hibernate, Struts2三大框架。**

导入SSH所需的jar

![70 2][]

在WEB-INF文件夹下新建一个web.xml文件，配置如下：

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
      <display-name>luyuan_crm</display-name>
      <welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>default.html</welcome-file>
        <welcome-file>default.htm</welcome-file>
        <welcome-file>default.jsp</welcome-file>
      </welcome-file-list>
      
      
      <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
      
      
      <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
      </context-param>
      
      
      <filter>
      	<filter-name>OpenSessionInViewFilter</filter-name>
      	<filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
      </filter> 
      
      <filter-mapping>
      	<filter-name>OpenSessionInViewFilter</filter-name>
      	<url-pattern>*.action</url-pattern>
      </filter-mapping>
      
       
      <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
      </filter>
      <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern> 
      </filter-mapping>
    </web-app>

在SRC下，新建applicationContext.xml，将Hibernate和Struts2交给Spring管理。

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:aop="http://www.springframework.org/schema/aop"
    	xmlns:tx="http://www.springframework.org/schema/tx"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans 
    	http://www.springframework.org/schema/beans/spring-beans.xsd
    	http://www.springframework.org/schema/context
    	http://www.springframework.org/schema/context/spring-context.xsd
    	http://www.springframework.org/schema/aop
    	http://www.springframework.org/schema/aop/spring-aop.xsd
    	http://www.springframework.org/schema/tx 
    	http://www.springframework.org/schema/tx/spring-tx.xsd">
    
    	
    	<context:property-placeholder location="classpath:jdbc.properties"/>
    	
    	
    	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 
    		<property name="driverClass" value="${jdbc.driverClass}"/>
    		<property name="jdbcUrl" value="${jdbc.url}"/>
    		<property name="user" value="${jdbc.username}"/>
    		<property name="password" value="${jdbc.password}"/>
    	</bean>
    	
    	
    	<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    		
    		<property name="dataSource" ref="dataSource"/>
    		
    		<property name="hibernateProperties">
    			<props>
    				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
    				<prop key="hibernate.show_sql">true</prop>
    				<prop key="hibernate.format_sql">true</prop>
    				<prop key="hibernate.hbm2ddl.auto">update</prop>
    			</props>
    		</property>
    		
    		
    		<property name="mappingResources">
    			<list>
    				<value>com/luyuan/crm/domain/User.hbm.xml</value>
    			</list>
    		</property>
    	</bean>
    	
    	
    	<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
    		<property name="sessionFactory" ref="sessionFactory"/>
    	</bean>
    	
    	
    	<tx:annotation-driven transaction-manager="transactionManager"/>
    </beans>

新建jdbc数据库配置文件jdbc.properties。

jdbc.driverClass=com.mysql.jdbc.Driver  
    jdbc.url=jdbc:mysql:///crm   #要连接的数据库名称
    jdbc.username=root 
    jdbc.password=root

引入日志记录配置文件log4j.properties，这个去拷贝apache log4j配置文件即可。

新建struts.xml配置文件。

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE struts PUBLIC
    	"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    	"http://struts.apache.org/dtds/struts-2.3.dtd">
    <struts>
    	
    	<constant name="struts.action.extension" value="action" />
    	
    	<package name="crm" extends="struts-default" namespace="/">
    		
    	</package>
    </struts>

至此，SSH的基本配置完成的差不多了，可以正式进行项目的开发。

**4.2.搭建项目基本骨架**

![70 3][]

创建BaseDao.java，定义常用的几个通用接口，一般为增删改查，因为一般表都需要CRUD操作。

/**
     * 通用的DAO的接口
     * @author hp
     *
     * @param <T>
     */
    public interface BaseDao<T> {
    	
    	public void save(T t);
    	
    	public void update(T t);
    	
    	public void delete(T t);
    	
    	public T getById(Serializable id);
    	
    	// 查询所有
    	public List<T> getAll();
    	
    	//统计个数的方法
    	public Integer getCount(DetachedCriteria detachedCriteria);
    	
    	//分页查询
    	public List<T> getByPage(DetachedCriteria detachedCriteria, Integer begin, Integer pageSize);
    }

BaseDaoImpl.java

![70 4][]

由于这里需要知道表映射成的实体类型的class, 需要用反射的方式获取该泛型中的T的具体class类型。可以采用在无参构造中获取。

/**
     * 通用的DAO的实现类
     * @author hp
     *
     * @param <T>
     */
    public class BaseDaoImpl<T> extends HibernateDaoSupport implements BaseDao<T>{
    
    	private Class clazz;
    	
    	public BaseDaoImpl() {
    		// 反射：第一步获得Class
    		Class clazz = this.getClass();// 正在被调用那个类的Class,CustomerDaoImpl或者LinkManDaoImpl。
    		// 查看JDK的API
    		Type type = clazz.getGenericSuperclass();// 参数化类型：BaseDaoImpl<Customer>，BaseDaoImpl<LinkMan>
    		// 得到这个type就是一个参数化的类型， 将type强转成参数化的类型:
    		ParameterizedType pType = (ParameterizedType) type;
    		// 通过参数化类型获得实际类型参数:得到一个实际类型参数的数组？Map<String,Integer>.
    		Type[] types = pType.getActualTypeArguments();
    		// 只获得第一个实际类型参数即可。
    		this.clazz = (Class) types[0];// 得到Customer、LinkMan、User
    	}
    	
    	@Override
    	public void save(T t) {
    		this.getHibernateTemplate().save(t);
    	}
    
    	@Override
    	public void update(T t) {
    		this.getHibernateTemplate().update(t);
    	}
    
    	@Override
    	public void delete(T t) {
    		this.getHibernateTemplate().delete(t);
    	}
    
    	@Override
    	public T getById(Serializable id) {
    		return (T) this.getHibernateTemplate().get(clazz, id);
    	}
    
    	@Override
    	public List<T> getAll() {	         
    		return (List<T>) this.getHibernateTemplate().find("from " + clazz.getSimpleName()); 
    	}
    
    	@Override
    	public Integer getCount(DetachedCriteria detachedCriteria) {
    		// 设置统计个数的条件:
    		detachedCriteria.setProjection(null); //清除条件的缓存
    		detachedCriteria.setProjection(Projections.rowCount());
    		List<Long> counts = (List<Long>) this.getHibernateTemplate().findByCriteria(detachedCriteria);
    		if(null != counts && counts.size() > 0) {
    			return counts.get(0).intValue();
    		}
    		return null;
    	}
    
    	@Override
    	public List<T> getByPage(DetachedCriteria detachedCriteria, Integer begin, Integer pageSize) {
    		detachedCriteria.setProjection(null);
    		return (List<T>) this.getHibernateTemplate().findByCriteria(detachedCriteria, begin, pageSize);
    	}
    
    	
    
    }

**4.3 登录注册模块**

注册界面：

![70 5][]

登录界面：

![70 6][]

**创建实体和表的映射**

创建实体：

public class User {
    	private long user_id;
    	private String user_code;
    	private String user_name;
    	private String user_password;
    	private String user_state;
    	
    	public long getUser_id() {
    		return user_id;
    	}
    	public void setUser_id(long user_id) {
    		this.user_id = user_id;
    	}
    	public String getUser_code() {
    		return user_code;
    	}
    	public void setUser_code(String user_code) {
    		this.user_code = user_code;
    	}
    	public String getUser_name() {
    		return user_name;
    	}
    	public void setUser_name(String user_name) {
    		this.user_name = user_name;
    	}
    	public String getUser_password() {
    		return user_password;
    	}
    	public void setUser_password(String user_password) {
    		this.user_password = user_password;
    	}
    	public String getUser_state() {
    		return user_state;
    	}
    	public void setUser_state(String user_state) {
    		this.user_state = user_state;
    	}
    	
    	
    }

创建映射文件User.hbm.xml：

<hibernate-mapping>
    	<class name="com.luyuan.crm.domain.User" table="sys_user">
    		<id name="user_id" column="user_id">
    			<generator class="native"/>
    		</id>
    		
    		<property name="user_code" column="user_code"/>
    		<property name="user_name" column="user_name"/>
    		<property name="user_password" column="user_password"/>
    		<property name="user_state" column="user_state"/>
    	</class>
    </hibernate-mapping>

DAO层创建UserDao.java

public interface UserDao extends BaseDao<User>{
    	//注册调用父类的save()
     
     //登录
     User login(User user);
     
     //账户是否已经被注册
     boolean isRegeisted(User user);
    }

实现类UserDaoImpl.java

public class UserDaoImpl extends BaseDaoImpl<User> implements UserDao {
    
    	@Override
    	public User login(User user) {
    		List<User> users = (List<User>) this.getHibernateTemplate().find("from User where user_code=? "
    				+ "and user_password=?", user.getUser_code(),
    				user.getUser_password());
    		if(null != users && users.size() > 0) {
    			return users.get(0);
    		}
    		return null;
    	}
    
    	@Override
    	public boolean isRegeisted(User user) {
    		List<User> users = (List<User>) this.getHibernateTemplate().find("from User where user_code=?", 
    				user.getUser_code());
    		if(null != users && users.size() > 0) {
    			return true;
    		}
    		return false;
    	}
    
    	
    }

业务service层创建UserService.java接口

public interface UserService {
    	void regeist(User user);
    	
    	User login(User user);
    }

实现类UserServiceImpl.java

//因为涉及保存操作，必须开启事务，不然Hibernate默认only-read
    @Transactional
    public class UserServiceImpl implements UserService {
    	
    	//注入Dao
    	private UserDao userDao;
    	
    	public void setUserDao(UserDao mUserDao) {
    		this.userDao = mUserDao;
    	}
    
    	@Override
    	public void regeist(User user) {
    		//先查询该账户是否已经注册
    		if(!userDao.isRegeisted(user)) {
    			user.setUser_password(MD5Utils.md5(user.getUser_password()));
    			user.setUser_state("1");
    			userDao.save(user);
    		} 
    	}
    
    	@Override
    	public User login(User user) {
    		//密码是密文传输的
    		user.setUser_password(MD5Utils.md5(user.getUser_password()));
    		return userDao.login(user);
    	}
    
    	
    }

并在applicationContext.xml添加相关Dao：

<bean id="userDao" class="com.luyuan.crm.dao.impl.UserDaoImpl">
    		<property name="sessionFactory" ref="sessionFactory"/>
    	</bean>

在web.action包下创建UserAction.java

public class UserAction extends ActionSupport implements ModelDriven<User> {
    	
    	//注入UserService
    	private UserService userService;
    
    	public void setUserService(UserService mUserService) {
    		this.userService = mUserService;
    	}
    
    	// 模型驱动使用的对象
    	private User user = new User();
    	
    	@Override
    	public User getModel() {
    		return user;
    	}
    	
    	
    	//注册
    	public String regeist() {
    		userService.regeist(user);
    		return LOGIN;
    	}
    	
    	//登录
    	public String login() {
    		// 调用业务层查询用户
    		User existUser = userService.login(user);
    		if(null == existUser) {
    			// 登录失败
    			//添加错误信息
    			this.addActionError("用户名或密码错误!");
    			return LOGIN;
    		} else {
    			//登录成功，将用户信息持久化
    			ActionContext.getContext().getSession().put("existUser", existUser);
    			return SUCCESS;
    		}
    	}
    }

并在applicationContext.xml添加相关Service：

<bean id="userService" class="com.luyuan.crm.service.impl.UserServiceImpl">
    		<property name="userDao" ref="userDao"/>
    	</bean>
    	
    	
    	
    	<bean id="userAction" class="com.luyuan.crm.web.action.UserAction" scope="prototype">
    		<property name="userService" ref="userService"/>
    	</bean>

在struts.xml添加下列配置：

<package name="crm" extends="struts-default" namespace="/">
    		<action name="user_*" class="userAction" method="{1}">
    			<result name="login">/login.jsp</result>
    			<result name="success" type="redirect">/index.html</result>
    		</action>
    </package>

测试注册：

![70 7][]

查询数据库，添加用户成功：

![70 8][]

测试登录：

**登录失败**

![70 9][]

登录成功，跳转到首页

![70 10][]

**4.4 客户管理模块**

**列表页**

**![70 11][]**

**添加页**

**![70 12][]**

**创建实体和表的映射**

创建实体：

public class Customer {
    	private Long cust_id;
    	private String cust_name;
    	private String cust_source;
    	private String cust_industry;
    	private String cust_level;
    	private String cust_phone;
    	private String cust_mobile;
            //设置器和访问器...
    }

创建映射文件Customer.hbm.xml：

<hibernate-mapping>
    	<class name="com.luyuan.crm.domain.Customer" table="cst_customer">
    		<id name="cust_id" column="cust_id">
    			<generator class="native"/>
    		</id>
    		
    		<property name="cust_name" column="cust_name"/>
    		<property name="cust_source" column="cust_source"/>
    		<property name="cust_industry" column="cust_industry"/>
    		<property name="cust_level" column="cust_level"/>
    		<property name="cust_phone" column="cust_phone"/>
    		<property name="cust_mobile" column="cust_mobile"/>
    		
    	</class>
    </hibernate-mapping>

然后在applicationContext.xml引入该映射文件

<property name="mappingResources">
    			<list>
    				<value>com/luyuan/crm/domain/User.hbm.xml</value>
    				<value>com/luyuan/crm/domain/Customer.hbm.xml</value>
    			</list>
    		</property>

创建CustomerDao.java

public interface CustomerDao extends BaseDao<Customer> {
    
    }

CustomerDaoImpl.java

public class CustomerDaoImpl extends BaseDaoImpl<Customer> implements CustomerDao {
    
    }

业务层Service

创建CustomerService.java

/**
     * 客户管理的Service的接口
     * @author hp
     *
     */
    public interface CustomerService {
    	void save(Customer customer);
    
    	PageBean<Customer> getByPage(DetachedCriteria detachedCriteria, Integer currPage,Integer pageSize);
    
    	Customer getById(Long cust_id);
    
    	void delete(Customer customer);
    
    	void update(Customer customer);
    
    	List<Customer> getAll();
    }

创建CustomerServiceImpl.java

public class CustomerServiceImpl implements CustomerService {
    
    	// 注入客户的DAO
    	private CustomerDao customerDao;
    
    	public void setCustomerDao(CustomerDao customerDao) {
    		this.customerDao = customerDao;
    	}
    		
    	// 业务层保存客户的方法:
    	@Override
    	public void save(Customer customer) {
    		customerDao.save(customer);
    	}
    
    	// 业务层根据ID查询客户的方法
    	@Override
    	public Customer getById(Long cust_id) {
    		return customerDao.getById(cust_id);
    	}
    
    	@Override
    	public void delete(Customer customer) {
    		customerDao.delete(customer);
    	}
    
    	@Override
    	public void update(Customer customer) {
    		customerDao.update(customer);
    	}
    
    	@Override
    	public List<Customer> getAll() {
    		return customerDao.getAll();
    	}
    	
    	// 业务层分页查询客户的方法:
    	@Override
    	public PageBean<Customer> getByPage(DetachedCriteria detachedCriteria, Integer currPage, Integer pageSize) {
    		PageBean<Customer> pageBean = new PageBean<>();
    		//封装当前页数
    		pageBean.setCurrPage(currPage);
    		//封装每页显示的条数
    		pageBean.setPageSize(pageSize);
    		//封装总条数
    		int totalCount = customerDao.getCount(detachedCriteria);
    		pageBean.setTotalCount(totalCount);
    		//封装总页数
    		int totalPage = (int) Math.ceil(totalCount * 1.0 / pageSize) ;
    		pageBean.setTotalPage(totalPage);
    		// 封装每页显示数据的集合
    		int begin = (currPage - 1) * pageSize;
    		List<Customer> data = customerDao.getByPage(detachedCriteria, begin, pageSize);
    		pageBean.setList(data);
    		return pageBean;
    	}
    
    }

创建CustomerAction.java

public class CustomerAction extends ActionSupport implements ModelDriven<Customer>{
    
    	//模型驱动使用的对象
    	private Customer customer = new Customer();
    	
    	@Override
    	public Customer getModel() {
    		return customer;
    	}
    
    	//注入Service
    	private CustomerService customerService;
    
    	public void setCustomerService(CustomerService customerService) {
    		this.customerService = customerService;
    	}
    	
    	// 接收分页数据:提供了两个参数名称：page 代表当前页数 和 rows 每页显示记录数
    	private Integer page = 1;
    	private Integer rows = 8;
    
    	public void setPage(Integer page) {
    		if (page == null) {
    			page = 1;
    		}
    		this.page = page;
    	}
    
    	public void setRows(Integer rows) {
    		if (rows == null) {
    			rows = 8;
    		}
    		this.rows = rows;
    	}
    	
    	/**
    	 * 分页查询客户的方法
    	 * @return
    	 * @throws IOException 
    	 */
    	public String getByPage() throws IOException {
    		// 创建离线条件查询
    		DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);
    		//调用业务层
    		PageBean<Customer> pageBean = customerService.getByPage(detachedCriteria, page, rows);
    		// 使用gson转成json
    		HashMap<String, Object> map = new HashMap();
    		map.put("total", pageBean.getTotalCount());
    		map.put("rows", pageBean.getList());
    		String json = new Gson().toJson(map);
    		System.out.println("json:" + json);
    		ServletActionContext.getResponse().setContentType("text/html;charset=UTF-8");
    		ServletActionContext.getResponse().getWriter().println(json);
    		return NONE;
    	}
    	
    	/**
    	 * 编写save方法：
    	 * 
    	 * @throws IOException
    	 */
    	public String save() throws IOException {
    		Map<String, String> map = new HashMap<String, String>();
    		try {
    			// 调用业务层:
    			customerService.save(customer);
    			map.put("msg", "保存成功!");
    		} catch (Exception e) {
    			e.printStackTrace();
    			map.put("msg", "保存失败!");
    		}
    		//换一种方式转json, 使用JSONlib转成JSON:
    		JSONObject jsonObject = JSONObject.fromObject(map);
    		System.out.println(jsonObject.toString());
    		ServletActionContext.getResponse().setContentType("text/html;charset=UTF-8");
    		ServletActionContext.getResponse().getWriter().println(jsonObject.toString());// {"msg":..}
    		return NONE;
    	}
    	
    	public String getById() throws IOException {
    		customer = customerService.getById(customer.getCust_id());
    		ServletActionContext.getResponse().setContentType("text/html;charset=UTF-8");
    		ServletActionContext.getResponse().getWriter().println(new Gson().toJson(customer));
    		return NONE;
    	}
    
    	public String update() throws IOException {
    		Map<String, String> map = new HashMap<String, String>();
    		try {
    			// 调用业务层:
    			customerService.update(customer);
    			map.put("msg", "保存成功!");
    		} catch (Exception e) {
    			e.printStackTrace();
    			map.put("msg", "保存失败!");
    		}
    		ServletActionContext.getResponse().setContentType("text/html;charset=UTF-8");
    		ServletActionContext.getResponse().getWriter().println(new Gson().toJson(map));
    		return NONE;
    	}
    
    	public String delete() throws IOException {
    		Map<String, String> map = new HashMap<String, String>();
    		try {
    			// 调用业务层:
    			customer = customerService.getById(customer.getCust_id());
    			customerService.delete(customer);
    			map.put("msg", "保存成功!");
    		} catch (Exception e) {
    			e.printStackTrace();
    			map.put("msg", "保存失败!");
    		}
    		
    		ServletActionContext.getResponse().setContentType("text/html;charset=UTF-8");
    		ServletActionContext.getResponse().getWriter().println(new Gson().toJson(map));
    
    		return NONE;
    	}
    }

未完待续。。。

[70]: /images/20220525/1dfc363b16d040e8b04f0f8265fbd962.png
[70 1]: /images/20220525/1e9c0b8f49a547ba9f3bb9c4035d350b.png
[2018051222565149]: /images/20220525/90971e54f14e455fa867a8a61362d668.png
[20180513211845364]: /images/20220525/a5db2cc8243d44bc98372d51e55c52c3.png
[70 2]: /images/20220525/258a652a176a4b11bf47364e5a67496e.png
[70 3]: /images/20220525/534907842ecf4cf3bce526f6f569074f.png
[70 4]: /images/20220525/4b934720dede4bfdb6edaf6b1e952bed.png
[70 5]: /images/20220525/a522ed2b068f482a9ca80c42a9bd485b.png
[70 6]: /images/20220525/bebea1e2ba8246a7b99fe1be130c6855.png
[70 7]: /images/20220525/8349c3d7ae1e40c7ad046498f87877f4.png
[70 8]: /images/20220525/0fa38f45d4ba4396b55dc5ecf0b654f5.png
[70 9]: /images/20220525/bf36c3416eae4056b2c1918b8d79d377.png
[70 10]: /images/20220525/47c6c71300f74a82aba20429b2d326e1.png
[70 11]: /images/20220525/c26c9e34baaa412fa3d3bc59ec4ae63d.png
[70 12]: /images/20220525/07921df522a04da2b9266844a3aea58f.png