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

最新推荐文章于 2024-05-10 06:22:02 发布

虎皮青椒没虎皮

最新推荐文章于 2024-05-10 06:22:02 发布

阅读量899

点赞数 1

分类专栏： java

本文链接：https://blog.csdn.net/baiyicanggou_wujie/article/details/80295216

版权

java 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

一.需求分析

主UI：

二.服务架构

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

三.数据表设计

部分E-R图：

用户表：

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 `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

在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>
  
  <!-- 配置Spring的核心监听器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  
  <!-- 加载Spring的配置文件的路径的，默认加载的/WEB-INF/applicationContext.xml -->
  <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>
  
   <!-- Struts2的核心过滤器 -->
  <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"/>
	
	<!--配置C3P0连接池-->
	<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>
	
	<!-- 配置SessionFactory -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
		<!-- 注入连接池 -->
		<property name="dataSource" ref="dataSource"/>
		<!-- 配置Hibernate的相关属性 -->
		<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>
	<!-- 配置Struts2的常量 -->
	<constant name="struts.action.extension" value="action" />
	
	<package name="crm" extends="struts-default" namespace="/">
		
	</package>
</struts>

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

4.2.搭建项目基本骨架

创建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

由于这里需要知道表映射成的实体类型的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 登录注册模块

注册界面：

登录界面：

创建实体和表的映射

创建实体：

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：

<!-- 配置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：

<!-- 配置Service -->
	<bean id="userService" class="com.luyuan.crm.service.impl.UserServiceImpl">
		<property name="userDao" ref="userDao"/>
	</bean>
	
	<!--注意：action不能为单例-->
	<!-- 配置Action -->
	<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>

测试注册：

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

测试登录：

登录失败

登录成功，跳转到首页

4.4 客户管理模块

列表页

添加页

创建实体和表的映射

创建实体：

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;
	}
}

未完待续。。。

虎皮青椒没虎皮

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
2
评论
基于SSH框架开发企业级CRM客户管理系统

一.需求分析二.服务架构采用单服务架构，后期的博客会将该项目扩展到服务集群和分布式缓存系统架构，敬请期待。三.数据表设计部分E-R图：用户表：CREATE TABLE `sys_user` ( `user_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '用户id', `user_code` varchar(32) NOT NULL COMME...
复制链接

扫一扫