客户信息管理系统3—客户信息的增加（二）

客户信息管理系统3—客户信息的增加（二）
1.4.4 CustomersService（业务层）：insert方法
package com.zhku.jsj144.zk.service;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

import com.zhku.jsj144.zk.dao.CustomersDao;
import com.zhku.jsj144.zk.daoImpl.CustomersDaoImplement;
import com.zhku.jsj144.zk.domain.Customers;
import com.zhku.jsj144.zk.domain.PageBean;
import com.zhku.jsj144.zk.utils.DaoFactory;
import com.zhku.jsj144.zk.utils.JdbcUtils;
import com.zhku.jsj144.zk.utils.TransactionUtils;

public class CustomersService {

//解耦合技术 [反射技术+配置文件+接口]
//对比分析：
//以前代码耦合的时候：写代码是直接new对象，那么需要以来具体的类，如果没有这些具体的类，这
//么这个业务层默认的程序员就没有办法继续做开发
//现在，解耦合：引入了接口，通过接口去引用了返回的实现类，将来实现类有了之后，只需要将实现类集成进来，
//然后配置文件修改以下即可，不用再去修改源代码了。

private CustomersDao CustomersDao=DaoFactory.getInstance().createDao(CustomersDao.class);
// private CustomersDao CustomersDao=new CustomersDao();
public int insert(Customers customers){
// CustomersDao CustomersDao=new CustomersDao();

// CustomersDao CustomersDao;
// try {
// CustomersDao = (CustomersDao) DaoFactory.getDao();//解耦合技术获得
// } catch (Exception e) {
// throw new RuntimeException(e);
// }
int count = CustomersDao.insert(customers);
return count;
}

//查询所有用户信息
public List selectAll() {
List resultList=CustomersDao.selectAll();//查询结果集
return resultList;
}

//删除一条记录，一个客户的信息
public void deleteOne(String id) {
CustomersDao.deleteOne(id);
}

// //批量删除
// public void deleteAll(String[] choose) {
// //开启事务处理，循环进行删除，每次删除一条记录，如果删除失败，则进行回滚事务，否则，最后进行提交事务，并关闭资源
//
// //问题思考：Connection对象应该出现待在dao层，而不应该出现在service层，这样导致service层和到层耦合了
// //思考：如何进行解耦呢？
// //这样Service层就不会使用dao层才会使用的Connection对象了。
// //方法：ThreadLocal类[线程本地类]的使用，可以解决这个问题
//
//
// //开启事务，需要获得Connection对象
// Connection con=null;
// try {
// con=JdbcUtils.getDatasourse().getConnection();//获得连接对象
// con.setAutoCommit(false);//开启事务
//
// for(int i=0;i<choose.length;i++){
// //手动管理事务，要自己传递Connection对象过去，确保Connection是唯一的
// CustomersDao.deleteOneTransaction(con,choose[i]);//每次删除一条记录
// }
// con.commit();//提交事务
// } catch (SQLException e) {
// try {
// con.rollback();//回滚事务
// } catch (SQLException e1) {
// e1.printStackTrace();
// }
// throw new RuntimeException("批量删除失败");
// }
// }

//完善后的deleteAll(String[] choose)方法
//批量删除
public void deleteAll(String[] choose) {
//开启事务处理，循环进行删除，每次删除一条记录，如果删除失败，则进行回滚事务，否则，最后进行提交事务，并关闭资源

//确保同一个线程使用的始终是同一个Connection对象
try{
//开启事务
TransactionUtils.startTransaction();
//批量删除操作
for(int i=0;i<choose.length;i++){
//手动管理事务，要自己传递Connection对象过去，确保Connection是唯一的
CustomersDao.deleteOneTransaction2(choose[i]);//每次删除一条记录
}
//提交事务
TransactionUtils.commit();
}catch(Exception e){
TransactionUtils.rollback();//回滚操作
throw new RuntimeException("批量删除失败...");
}finally{
//释放资源
TransactionUtils.relase();
}
}

public Customers getUpdateInfo(String id) {
Customers customers=CustomersDao.getUpdateInfo(id);
return customers;
}

public void update(Customers customers) {
CustomersDao.update(customers);
}

public List selectCondition(String conditionName, String keyWords) {
List customersList=CustomersDao.selectCondition(conditionName,keyWords);
return customersList;
}

//分页查询业务逻辑，目的获取分页pageBean的5个信息
//分页推导公式：
//1. 总页数=（总记录数+每页记录数-1）/每页记录数
//2. 初始索引=(当前页数-1)*每页记录数
public PageBean pageQuery(String num) {

int totalRecord=CustomersDao.selectAllCount();//总记录数
int pageRecord=10;//每页记录数【默认是每页10条记录】
int totalPage=(totalRecord+pageRecord-1)/pageRecord;//总页数
int currentPage=Integer.parseInt(num);//当前页数

//主要是初始索引参数，以及每页的记录数作为参数
int start=(currentPage-1)*pageRecord;//开始索引
List<Customers> dataList=CustomersDao.selectPageList(start,pageRecord);//当前页记录数

//将pageBean的信息封装起来
PageBean pageBean=new PageBean();
pageBean.setTotalPage(totalPage);
pageBean.setTotalRecord(totalRecord);
pageBean.setPageRecord(pageRecord);
pageBean.setCurrentPage(currentPage);
pageBean.setDataList(dataList);

return pageBean;
}
}

1.4.5 CustomersDao（dao层接口）：insert方法
package com.zhku.jsj144.zk.dao;

import java.sql.Connection;
import java.util.List;

import org.junit.Test;

import com.zhku.jsj144.zk.domain.Customers;
//将Dao层抽象成一个接口，然后再写它的实现类
//目的：为了Service层与Dao层的解耦合。
//原因：每次Service调用一个方法，都要new一个Dao层对象，这样，就增加了Service层和Dao层的耦合性
//因此，通过书写接口，然后书写配置文件，利用反射技术，得到Dao层的对象，而不用每次new对象
//好处：提高了扩展性。

//应用场景：解耦合【接口+配置文件+反射技术】
// 某个模块不会写，自己可以定义一个接口，然后外包给别人去实现，利用解耦合技术，然后把别人实现好的方法，即：接口的实现类
//继承进来，在进行书写相应的配置文件，即可达成目的

public interface CustomersDao {

//插入用户信息
public abstract int insert(Customers customers);

//查询用户信息
public abstract List selectAll();

//删除一条记录
public abstract void deleteOne(String id);

//删除一条记录，并手动管理事务
public abstract void deleteOneTransaction(Connection con,String id);

//删除一条记录，并手动管理事务[写法2]
public abstract void deleteOneTransaction2(String id);

//查询一条用户记录信息，用于修改使用
public abstract Customers getUpdateInfo(String id);

//修改一条用户记录信息
public abstract void update(Customers customers);

//条件查询
public abstract List selectCondition(String conditionName, String keyWords);

//查找总记录个数
public abstract int selectAllCount();

//分页查询
public abstract List<Customers> selectPageList(int start, int pageRecord);

}

1.4.6 CustomersDaoImplement（dao层接口实现类）：insert方法
package com.zhku.jsj144.zk.daoImpl;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.UUID;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.Test;

import com.zhku.jsj144.zk.dao.CustomersDao;
import com.zhku.jsj144.zk.domain.Customers;
import com.zhku.jsj144.zk.utils.JdbcUtils;
import com.zhku.jsj144.zk.utils.TransactionUtils;

public class CustomersDaoImplement implements CustomersDao {

//插入用户信息
/* (non-Javadoc)
* @see com.zhku.jsj144.zk.dao.CustomersDao#insert(com.zhku.jsj144.zk.domain.Customers)
*/
@Override
public int insert(Customers customers){
//调用工具类进行插入操作
// QueryRunner qr=new QueryRunner();//没有获取连接
try{
QueryRunner qr=new QueryRunner(JdbcUtils.getDatasourse());

//id，用UUID工具进行生成
String id=getId();

//参数数组
Object[] params=new Object[]{id,customers.getName(),customers.getGender(),
customers.getBirthday(),customers.getEmail(),customers.getCellphone(),
customers.getPreference(),customers.getType(),customers.getDescription()};

int count = qr.update("insert into customers values(?,?,?,?,?,?,?,?,?)", params);
System.out.println("count:"+count);
return count;//返回插入结果
}catch(SQLException e){
throw new RuntimeException(e);
}

}

//生成并获取id
private String getId(){
String id=UUID.randomUUID().toString();
id=id.replace("-", "");
return id;
}

//查询用户信息
/* (non-Javadoc)
* @see com.zhku.jsj144.zk.dao.CustomersDao#selectAll()
*/
@Override
public List selectAll() {
QueryRunner qr=new QueryRunner(JdbcUtils.getDatasourse());
try {
//返回查询结果集
List resultList = qr.query("select * from customers", new BeanListHandler(Customers.class));
return resultList;
} catch (SQLException e) {
throw new RuntimeException(e);
}
}

//删除一条记录
/* (non-Javadoc)
* @see com.zhku.jsj144.zk.dao.CustomersDao#deleteOne(java.lang.String)
*/
@Override
public void deleteOne(String id) {
QueryRunner qr=new QueryRunner(JdbcUtils.getDatasourse());
try {
qr.update("delete from customers where id=?", id);
} catch (SQLException e) {
throw new RuntimeException(e);//抛出运行时异常
}

}

//删除一条记录，并手动管理事务
@Override
public void deleteOneTransaction(Connection con,String id) {
QueryRunner qr=new QueryRunner();
try {
qr.update(con,"delete from customers where id=?", id);
} catch (SQLException e) {
throw new RuntimeException(e);//抛出运行时异常
}
}

//删除一条记录，并手动管理事务[写法2]
@Override
public void deleteOneTransaction2(String id) {
QueryRunner qr=new QueryRunner();
try {
//ThreadLocal类【线程本地类】的使用：确保同一个线程使用的始终是同一个Connection对象
qr.update(TransactionUtils.getConnection(),"delete from customers where id=?", id);
} catch (SQLException e) {
throw new RuntimeException(e);//抛出运行时异常
}
}

//查询一条用户记录信息，用于修改使用
@Override
public Customers getUpdateInfo(String id) {
QueryRunner qr=new QueryRunner(JdbcUtils.getDatasourse());
Customers customers=null;
try {
customers = qr.query("select * from customers where id=?", new BeanHandler(Customers.class),id);
return customers;
} catch (SQLException e) {
throw new RuntimeException(e);//抛出运行时异常
}
}

//修改一条用户记录信息
@Override
public void update(Customers customers) {
QueryRunner qr=new QueryRunner(JdbcUtils.getDatasourse());
Object[] params={customers.getName(),customers.getGender(),customers.getBirthday(),
customers.getCellphone(),customers.getEmail(),customers.getPreference(),
customers.getType(),customers.getDescription(),customers.getId()};
try {
qr.update("update customers set name=?,gender=?,birthday=?,cellphone=?,email=?,"
+ "preference=?,type=?,description=? where id=?", params);
} catch (SQLException e) {
throw new RuntimeException(e);//抛出运行时异常
}
}

//条件查询
@Override
public List selectCondition(String conditionName, String keyWords) {
QueryRunner qr=new QueryRunner(JdbcUtils.getDatasourse());
try {
//select * from customers where name like '% 张 %'
List customersList=qr.query("select * from customers where "+conditionName+" like ?", new BeanListHandler(Customers.class),"%"+keyWords+"%");
return customersList;
} catch (SQLException e) {
throw new RuntimeException(e);//抛出运行时异常
}
}

//查找总记录个数
@Override
public int selectAllCount() {
QueryRunner qr=new QueryRunner(JdbcUtils.getDatasourse());
try {
// //异常：java.lang.ClassCastException: java.lang.Long cannot be cast to java.lang.Integer
// int count = (Integer) qr.query("select count(*) from customers", new ScalarHandler());

long count = (Long) qr.query("select count(*) from customers", new ScalarHandler());
return (int)count;//此处再强制转换
} catch (SQLException e) {
throw new RuntimeException(e);//抛出运行时异常
}
}

//分页查询
// 物理分页
// 在sql查询时，从数据库只检索分页需要的数据
// mysql物理分页，采用limit关键字
// 例如：检索11-20条 select * from user limit 10,10 ;
@Override
public List<Customers> selectPageList(int start, int pageRecord) {
//参数：初始索引，每页的记录数
QueryRunner qr=new QueryRunner(JdbcUtils.getDatasourse());
try {
//eg: select * from user limit 10,10 ;
List<Customers> pageList = qr.query("select * from customers limit ?,?", new BeanListHandler(Customers.class),start,pageRecord);
return pageList;
} catch (SQLException e) {
throw new RuntimeException(e);//抛出运行时异常
}
}

}

1.4.7 DaoFactory（dao层工厂）

package com.zhku.jsj144.zk.utils;

import java.util.ResourceBundle;
//用于创建到的工厂类
//工厂类很多时候会被弄成单例模式

public class DaoFactory {

private DaoFactory(){};
//一个工厂类实例
private static DaoFactory instance=new DaoFactory();
//获取工厂类实例
public static DaoFactory getInstance(){
return instance;
}

//用于返回传进来的一个类的实例对象出去
public <T> T createDao(Class<T> t){
//CustomerDao.class --> CustomerDao
String simpleName=t.getSimpleName();//获取自己吗对象的名字
//读取一个配置文件
//CustomersDao=com.zhku.jsj144.zk.daoImpl.CustomersDaoImplement
String clazzName=ResourceBundle.getBundle("dao").getString(simpleName);

try {
return (T)Class.forName(clazzName).newInstance();
} catch (Exception e) {
e.printStackTrace();
return null;
}

}

/*
* 自己写的方法
*
public static Object getDao(){

ResourceBundle bundle=ResourceBundle.getBundle("dao");//读取dao.properties配置文件
//配置文件内容：CustomersDao=com.zhku.jsj144.zk.daoImpl.CustomersDaoImplement
//左边：接口  右边：接口的实现类
String implClass=bundle.getString("CustomersDao");

//通过类的字符串名，利用反射，创建实例对象
Class<?> clazz;
try {
clazz = Class.forName(implClass);
Object instance = clazz.newInstance();//实例对象
return instance;//返回创建的实例对象：CustomersDaoImplement实例对象
} catch (Exception e) {
throw new RuntimeException(e);
}
}
*/
}

1.4.8 dao.properties（dao相关配置文件）

CustomersDao=com.zhku.jsj144.zk.daoImpl.CustomersDaoImplement

说明：

左边的键是：dao接口，右边的值是：dao接口的实现类

目的：

在service层调用dao工厂的一个方法：创建工厂实例方法去得到一个dao的实现类的一个实例，首先，读取到dao.properties配置文件里的dao和dao实现类的数值，然后获取后，通过反射技术，创建出这样的一个实例（dao接口实现类的实例）来。

1.4.9 JdbcUtils（工具类）               
package com.zhku.jsj144.zk.utils;

import java.sql.Connection;
import java.sql.SQLException;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;
/*
* 工具类
* 1、获得数据源【c3p0】
* 2、获得c3p0连接池中的一个连接
*/
public class JdbcUtils {

private static DataSource ds=new ComboPooledDataSource();//数据库连接池的数据源

public static DataSource getDatasourse(){
return ds;//返回数据库连接池的数据源
}
public Connection getConnection() throws SQLException{
return ds.getConnection();//从数据库连接池中获取一个连接
}
}

1.4.10 c3p0-config.xml（连接池配置文件）
<c3p0-config>
<default-config>
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost/customer_system?useSSL=false</property>
<property name="user">root</property>
<property name="password">1234</property>
</default-config>

<!-- This app is massive! -->
<named-config name="intergalactoApp">
<property name="maxPoolSize">1000</property>
<property name="maxStatements">0</property>
<property name="maxStatementsPerConnection">5</property>

</named-config>
</c3p0-config>

项目详细代码资源:

本人的github项目地址
https://github.com/Forever99/customer_system