2.5三层架构和DBUtils

三层架构和Apache的DbUtils

回顾

1. 封装数据库工具类
   四个基本功能 (1)加载驱动 (2) 获取连接 (3) 释放连接 (4) 执行命令 （String sql,Object…params）
2. 封装查询数据
   把数据库中数据封装成实体对象
3. DAO模式
   把数据库操作封装起来，把业务逻辑代码和数据访问代码隔离开。职责分离，降低耦合性
   四个部分 1 DAO接口 2 DAO实现类 3 实体类 4 数据库工具类
4. 连接池
   Druid连接池的使用

今日内容

1. 三层架构
2. JDBC控制事务
3. 三层实现事务
4. ThreadLocal类使用
5. Apache的DbUtils工具类使用

第一节 三层架构

• DAO模式的缺点
  DAO模式仅仅提供了对数据访问的操作,业务逻辑代码和负责展示的代码是耦合在一起的，所以需要把业务代码和负责展示的代码分离开就出现了三层架构。

1.1 什么是三层架构

• 三层架构(3-tier architecture) 就是将整个业务应用划分为：界面（表示）层（User Interface layer）、业务逻辑层（Business Logic Layer）、数据访问层（Data Access Layer）。区分层次的目的即为了高内聚低耦合的思想。

• 每层功能：

  1. 数据访问层：是对数据库的基本操作（增删改查等），具体为业务逻辑层提供数据服务。
  2. 业务逻辑层：主要是针对具体的问题的操作，对数据业务逻辑处理，比如注册、转账等。
  3. 界面（表示）层：主要界面方式有WEB或Window窗口、控制台等，负责向用户展现特定业务数据、采集用户的输入信息和操作。

1.2 引用关系

• 表示层调用业务逻辑层，业务逻辑层调用数据访问层。下层为上层提供服务。上层调用下层。
  

1.3 分层优缺点

• 优点：
  1. 有助于分层开发
  2. 无损替换
  3. 降低层与层之间的依赖
  4. 提高代码的重用性
• 缺点：
  1. 增加开发成本
  2. 降低系统性能

1.4 业务层(service)

• 什么是业务？
  代表用户完成的一个业务功能，可以由一个或多个DAO的调用组成。（软件所提供的一个功能都叫业务）
  转账：一次转账。两个DAO操作：扣钱，加钱

• 在DAO模式基础上添加service层，service层的包命名规则

  1. 接口包名：service
  2. 接口名：xxxService
  3. 实现类包名：impl
  4. 实现类：xxxServiceImpl

• 三层架构演示

1. 业务层Service接口代码：

/*
	service层是业务层，是个接口,业务中方法名可以和DAO中方法相同，也可以不相同
*/
public interface EmpService {
    //1查询
    List<Emp> findAll();
    //2更新
    void update(Emp e);
    //3删除
    void delete(int empno);
    //4添加
    void add(Emp e);
}

2. 业务层service实现类代码

/*
	业务层实现类主要是创建DAO层的数据访问对象，然后调用方法完成业务功能
*/
public class EmpServiceImpl implements EmpService {
    private EmpDao empDao = new EmpDaoImpl();
    @Override
    public List<Emp> findAll() {
        List<Emp> list = empDao.findAll();
        return list;
    }

    @Override
    public void update(Emp e) {
		empDao.update(e);
    }

    @Override
    public void delete(int empno) {
			empDao.delete(empno);
    }

    @Override
    public void add(Emp e) {
		empDao.add(e);
    }
}

第二节 JDBC控制事务

回顾：

• 事务是由完成任务的一个或多个操作组成，这些操作作为一个整体不能分割，要么全部执行成功，要么全部失败。

• 事务四个特性：

  1. 原子性（Atomicity，或称不可分割性）
  2. 一致性（Consistency）
  3. 隔离性（Isolation，又称独立性）
  4. 持久性（Durability）

• MySQL中与事务控制有关的SQL语句：

  1. BEGIN或START TRANSACTION;开启事务
  2. COMMIT;提交事务
  3. ROLLBACK;回滚事务

• 在JDBC中实现事务控制需要使用Connection对象提供的方法

  1. conn.setAutoCommit(false);开启事务
  2. conn.commit();提交事务
  3. conn.rollback();回滚事务

• 案例实现：使用事务实现转账

（1）准备表

CREATE TABLE account(
	`id` INT PRIMARY KEY,
	`name` VARCHAR(20) NOT NULL,
	`money` DOUBLE(10,2)
)
  

（2）代码实现

public static void main(String[] args) {
		Connection connection=null;
		PreparedStatement pstat1=null;
		PreparedStatement pstat2=null;
		
		//1注册驱动
		try {
			Class.forName("com.mysql.jdbc.Driver");
			//2获取连接
			connection=DriverManager.getConnection("jdbc:mysql://localhost:3306/school", "root", "root");
			//3创建命令
			//3.1开启事务 ，设置事务自动提交为false
			connection.setAutoCommit(false);
			pstat1=connection.prepareStatement("update account set money=money-1000 where name='张莎强'");
			pstat1.executeUpdate();
			//int c=10/0;
			pstat2=connection.prepareStatement("update account set money=money+1000 where name='小苍'");
			pstat2.executeUpdate();
			
			System.out.println("转账成功...");
			//3.2提交事务
			connection.commit();
			
		} catch (Exception e) {
			System.out.println("出现异常");
			try {
				connection.rollback();//出现问题，要回滚(撤销事务做过的修改)
				connection.commit();//可加也不不加
			} catch (SQLException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
		}finally {
				try {
                    if(pstat1!=null)
					pstat1.close();
                    if(pstat2!=null)
                    pstat2.close();     
                    if(connection!=null)
                    connection.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

第三节 三层实现事务

3.1项目准备

​ 创建Java项目

​ 导入需要的jar包 mysql驱动、 druid.jar

​ 添加数据库配置文件

• db.properties

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/account
username=root
password=1234
#<!-- 初始化连接 -->
initialSize=10
#最大连接数量
maxActive=50
#<!-- 最小空闲连接 -->
minIdle=5
#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=5000

3.2编写Java代码

• 应用三层架构，其中dao层，我们已经搭建过，只需要添加service业务层和view视图层

3.2.1包结构

com.公司名.dao

com.公司名.dao.impl

com.公司名.service

com.公司名.service.impl

com.公司名.view

com.公司名.utils

com.公司名.domain

3.2.2编写DbUtils工具类

• DBUtils工具类,优化获取连接,优化事务操作

public class DbUtils {
	private static DruidDataSource ds=null;
   //静态代码块
    static {
        InputStream is = DbUtils.class.getClassLoader().getResourceAsStream("db.properties");
        Properties properties=new Properties();
        try {
            properties.load(is);
            dataSource= (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
	/**
	 * 获取数据源
	 * @return 连接池
	 */
	public static DataSource getDataSource(){
		return ds;
	}
	
	/**
	 * 从当前线程上获取连接
	 * @return 连接
	 * @throws SQLException
	 */
	public static Connection getConnection() throws SQLException{
		//--从
		try {
            Connection connection = ds.getConnection();
            return connection;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
	}
 //关闭
    public static void close(){
        Connection connection = getConnection();
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
	/**
	 *---- 开启事务
	 * @throws SQLException
	 */
	public static void startTransaction() throws SQLException{
		//获取连接//开启事务
		getConnection().setAutoCommit(false);
	}
	
	/**
	 *--- 事务提交
	 */
	public static void commitAndClose(){
		try {
			//获取连接
			Connection conn = getConnection();
			//提交事务
			conn.commit();
			//释放资源
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * ----事务回滚
	 */
	public static void rollbackAndClose(){
		try {
			//获取连接
			Connection conn = getConnection();
			//事务回滚
			conn.rollback();
			//释放资源
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}

3.2.3编写DAO层代码

• DAO层进行具体数据库操作

实体类：

public class Account {
    private int id;
    private String name;
    private double money;

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public Account() {
    }

    public Account(int id, String name, double money) {
        this.id = id;
        this.name = name;
        this.money = money;
    }
}

public class AccountDaoImpl implements AccountDao {
    private Connection connection = null;
    private PreparedStatement preparedStatement = null;
    private ResultSet resultSet = null;
    @Override
    public void updateSave(int cardNo, double money) {
        connection = DBUtils.getConnection();
        String sql = "update account set money = money+? where id = ?";
        try {
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setDouble(1, money);
            preparedStatement.setInt(2, cardNo);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            DBUtils.close();
        }
    }

    @Override
    public void updateTake(int cardNo, double money) {
        connection = DBUtils.getConnection();
        String sql = "update account set money = money-? where id = ?";
        try {
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setDouble(1, money);
            preparedStatement.setInt(2, cardNo);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            DBUtils.close();
        }
    }
}

3.2.4编写业务层代码

/**
 * jdbc+threadlocal
 * 
 * @author Administrator
 *
 */
public class AccountServiceImpl {
    
	/**
	 * 转账业务逻辑
	 * @param from
	 * @param to
	 * @param money
	 * @throws Exception 
	 */
	public  void transfer(int from, int to,double money) throws Exception {
		AccountDaoDButis accountDao = new AccountDaoDButis();
		try {
			//开启事务
			DataSourceUtils.startTransaction();
			//1.转出
			accountDao.out(from,money);
			//2.转入
			accountDao.in(to,money);
			DataSourceUtils.commitAndClose();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace
			DataSourceUtils.rollbackAndClose();
			throw e; //接着向外抛
		}
	}

}

3.2.4编写视图层代码

• 视图层主要用于用户输入转账内容，调用业务层

public class StartView {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("欢迎登陆转账系统：");
        System.out.println("请输入卡号：");
        int from  = scanner.nextInt();
        System.out.println("请输入对方卡号");
        int to = scanner.nextInt();
        System.out.println("请输入转账金额");
        double money = scanner.nextDouble();
        //调用业务层
        AccountService accountService = new AccountServiceImpl();
        //调用转账方法，传入参数
        accountService.transfer(from, to, money);
    }
}

第四节 ThreadLocal类

• 三层结合事务现存在的问题：
  当前事务出现异常，一个DAO操作执行成功，一个DAO失败，则需要进行回滚，但是却发现回滚失败了，原因是在整个事务操作过程中，每一个环节应用的数据库连接对象都不是同一个，所以事务的控制从头到尾不是一个连接。

• 需要使用ThreadLocal， 可以在整个线程（单条执行路径）所持有的Map中，存储一个键值，值是与当前线程关联的Connection对象，只要保证线程是同一个，则获取到的Connection是同一个。

4.1优化DbUtils

public class DbUtils {
	private static DruidDataSource ds=null;
    //创建
    private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
   //静态代码块
    static {
        InputStream is = DbUtils.class.getClassLoader().getResourceAsStream("db.properties");
        Properties properties=new Properties();
        try {
            properties.load(is);
            dataSource= (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
	/**
	 * 获取数据源
	 * @return 连接池
	 */
	public static DataSource getDataSource(){
		return ds;
	}
	
	/**
	 * 从当前线程上获取连接
	 * @return 连接
	 * @throws SQLException
	 */
	public static Connection getConnection() throws SQLException{
		try {
           //--从线程获取链接
            Connection connection = threadLocal.get();
            if(connection==null){
                //第一次获取 创建一个连接 和当前的线程绑定
                connection = ds.getConnection();
                	 //----绑定
                threadLocal.set(connection);
            }
            return connection;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
	}
 //关闭
    public static void close(){
        Connection connection = getConnection();
        try {
            //和当前线程解绑
            threadLocal.remove();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
	/**
	 *---- 开启事务
	 * @throws SQLException
	 */
	public static void startTransaction() throws SQLException{
		//获取连接//开启事务
		getConnection().setAutoCommit(false);
	}
	
	/**
	 *--- 事务提交
	 */
	public static void commitAndClose(){
		try {
			//获取连接
			Connection conn = getConnection();
			//提交事务
			conn.commit();
			//释放资源
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * ----事务回滚
	 */
	public static void rollbackAndClose(){
		try {
			//获取连接
			Connection conn = getConnection();
			//事务回滚
			conn.rollback();
			//释放资源
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}

4.2优化DAO层代码

public class AccountDaoImpl implements AccountDao {
    private Connection connection = null;
    private PreparedStatement preparedStatement = null;
    private ResultSet resultSet = null;
    @Override
    public void updateSave(int cardNo, double money) {
        connection = DbUtils.getConnection();
        String sql = "update account set money = money+? where id = ?";
        try {
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setDouble(1, money);
            preparedStatement.setInt(2, cardNo);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
//            DBUtils.close();不在dao调用关闭连接的方法！
        }
    }

    @Override
    public void updateTake(int cardNo, double money) {
        connection = DbUtils.getConnection();
        String sql = "update account set money = money-? where id = ?";
        try {
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setDouble(1, money);
            preparedStatement.setInt(2, cardNo);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
//            DBUtils.close();不在dao调用关闭连接的方法！
        }
    }
}

第五节 Apache的DbUtils使用

• Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。

• 下载地址:http://commons.apache.org/proper/commons-dbutils/download_dbutils.cgi

5.1 DbUtils简介

• DbUtils是java编程中的数据库操作实用工具，小巧简单实用。

• 功能：

  1. 对于数据表的读操作，可以把结果转换成List，Array，Set等java集合，便于程序员操作。
  2. 对于数据表的写操作，也变得很简单（只需写sql语句）。

• DbUtils包括主要类

DbUtils类：启动类

ResultSetHandler接口：转换类型接口

​ –ScalarHandler类：适合获取一行一列数据。

​ –BeanHandler类：实现类,把记录转成对象。

​ –BeanListHandler类：实现类，把记录转化成List，使记录为JavaBean类型的对象

​ --ArrayHandler类：实现类，把记录转化成数组

​ --ArrayListHandler类：把记录转化成数组，并放入集合中

​ --ColumnListHandler类：取某一列的数据。封装到List中。

QueryRunner类：执行SQL语句的类

5.2 DbUtils使用步骤

5.2.1 项目准备

• 创建项目
• 导入jar包 、配置文件
  MySQL驱动包
  commons-dbutils-1.6.jar
  druid-1.1.5.jar
  druid.properties配置文件

5.2.2 创建数据源工具类

由于Apache的DBUtils工具需要一个数据源对象，所以需要创建工具类返回数据源对象

DruidUtils.java

public class DruidUtils {
    private static DruidDataSource dataSource;
    static {
        try {
            Properties properties=new Properties();
            InputStream is=DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            properties.load(is);

            dataSource= (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static DataSource getDataSource(){
        return dataSource;
    }
}

5.2.3 实现代码

public class ResultHanlderTest {
	@Test
	public void testBeanHandler() throws SQLException {
		// BeanHandler:适合取单行单列数据
		QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());
		Employee query = runner.query("select * from emp where empno=1234 ", new BeanHandler<Employee>(Employee.class));
		System.out.println(query.toString());
	}
  
  	@Test
	public void testBeanListHandler() throws SQLException {
		// BeanHandler:适合取多行多列数据
		QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());
		List<Employee> query2 = runner.query("select * from emp", new BeanListHandler<Employee>(Employee.class));
		for (Employee employee : query2) {
			System.out.println(employee);
		}
	}
    @Test
	public void testScalarHandler() throws SQLException {

		// ScalarHandler:适合取单行单列数据
		QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());

		Object query = runner.query("select count(*) from emp ", new ScalarHandler());
		System.out.println(query);
	}
	@Test
	public void testArrayHander() throws SQLException {

		// ArrayHandler:适合取1条记录。把该条记录的每列值封装到一个数组中Object[]
		QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());

		Object[] query = runner.query("select * from school where empno = ?", new ArrayHandler(), 1234);

		for (Object object : query) {

			System.out.println(object);
		}

	}

	@Test
	public void testArrayListHander() throws SQLException {

		// ArrayHandler:适合取1条记录。把该条记录的每列值封装到一个数组中Object[]
		QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());

		List<Object[]> query = runner.query("select * from emp ", new ArrayListHandler());

		for (Object[] objects : query) {
			for (Object object : objects) {

				System.out.println(object);
			}
		}

	}

	@Test
	public void testColumnListHander() throws SQLException {

		// ColumnListHandler:取某一列的数据。封装到List中。
		QueryRunner runner = new QueryRunner(DruidUtils.getDataSource());

		List<Object> query = runner.query("select * from emp ", new ColumnListHandler<Object>(2));

		for (Object objects : query) {

			System.out.println(objects);

第六节 封装查询方法(扩展)

6.1 RowMapper接口方式

• 步骤1 定义封装规则接口

RowMapper接口

//封装规则。封装对象为泛型，通用。参数需要的是ResultSet对象
public interface RowMapper<T> {
    T getRow(ResultSet rs);
}

• 步骤2 DbUtils中增加查询方法

//查询通用方法 泛型方法。返回值为泛型集合，因为查询可能是单个或多个
//参数:sql语句、封装方式、参数列表
    public static <T> List<T> executeQuery(String sql , RowMapper<T> mapper,Object... params){
        PreparedStatement preparedStatement = null;
        Connection connection = getConnection();
        ResultSet rs = null;
        //定义泛型集合，类型由封装方式的具体对象来决定
        List<T> list=new ArrayList<T>();
        try {
            preparedStatement = connection.prepareStatement(sql);
            //循环为占位符赋值
            for(int i= 0;i<params.length;i++){
                preparedStatement.setObject(i+1, params[i]);
            }
            rs = preparedStatement.executeQuery();
            //迭代
            while(rs.next()){
                //获得一行数据，调用封装方式，得到对象，添加到集合中
                list.add(mapper.getRow(rs));
            }
            return list;
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            closeAll(rs, preparedStatement, connection);
        }	
        return null;
    }

• 步骤3：编写接口实现类

//定义具体的封装方式，决定通用查询封装的是具体某个对象
//遍历ResultSet，取值做对象属性的赋值
public class AccountRowMapper implements RowMapper<Account> {
    @Override
    public Account getRow(ResultSet rs) {
        Account account = new Account();
        try {
            account.setId(rs.getInt(1));
            account.setName(rs.getName(2));
            account.setMoney(rs.getDouble(3));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return account;
    }
}

6.2 反射方式

• 通用性更强，理解即可

 //返回List集合的方法
    public  static <T> List<T> executeQuery(String sql,  Class<T> class1,Object... params){
        List<T> list=new ArrayList<>();
        Connection conn=null;
        PreparedStatement pstat=null;
        ResultSet rs=null;
        //查询数据
        try {
            conn=getConnection();
            pstat = conn.prepareStatement(sql);
            if(params!=null){
                for (int i = 0; i < params.length; i++) {
                    pstat.setObject(i+1, params[i]);
                }
            }
            rs = pstat.executeQuery();
            //获取rs中的列名
            ResultSetMetaData metaData = rs.getMetaData();
            while(rs.next()){
                //创建一个对象
              	 T t=class1.newInstance();
                 for(int i=0;i<metaData.getColumnCount();i++){
                 	 String columnLabel=metaData.getColumnLabel(i+1);
                 	 Object value = rs.getObject(columnLabel);//empno  ename job
                     //System.out.println(columnLabel+"==="+value);
                     //创建属性描述符
                	 try {
                 		 PropertyDescriptor pd=new PropertyDescriptor(columnLabel, class1);
                 		 if(pd!=null){
                		    //System.out.println(pd.getName());
                 		    Method writeMethod = pd.getWriteMethod(); //setEmpno setEname setJob
                		    writeMethod.invoke(t,value);
                 	     }
                      } catch (Exception e) {
                		 continue;
                      }
                 }	
                list.add(t);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            closeAll(conn, pstat, rs);
        }
        return list;
    }

总结

1. 三层架构 DAO、Service、UI Utils 工具类 domain实体类

2. JDBC操作事务，结合事务的三层架构，在DBUtils工具类里，封装对事务的一系列操作

3. ThreadLocal解决多个DAO操作，connection对象不同步的问题。

4. Apache DBUtils的使用，QueryRunner ResultSetHanlder 接口

5. 扩展理解

作业题

1. 使用三层架构重构学生管理系统，要求实现正删改查，基于控制台实现即可
   要求可以对学生信息进行添加、修改、删除、查询的功能

面试题

1. 什么三层架构?
2. JDBC事务控制方法有那些