事务，连接池，分包分层（MVC设计模式）

-事务的作用

保证一个业务要么全部执行成功要么全部执行失败

-事务的四大原则

 A：事务的原子性： 每一个都事务最小的原子单位 不能进行分割==>要么同时都执行成功要么同时执行失败 

C： 事务的一致性 :要么是在执行前的状态要么执行后的状态，执行后系统状态是一致的

D： 事务的隔离性 : 并发执行的事务彼此无法看到对方的中间状态

L：  持久性 : 只要commit后 永久包存到数据库了

 

-操作事务

1.使用mysql数据库操作事务

2.使用Java来操作事务

 

-事务的隔离级别

事务隔离级别	脏读	不可重复读	幻读	数据库默认级别
未提交读（Read uncommitted）	可能	可能	可能
已提交读（Read committed）	不可能	可能	可能	Oracle/SQL Server
重复（Repeatable read）	不可能	不可能	可能	MySQL
可串行化（SERIAUZABLE）	不可能	不可能	不可能	一般使用少

1. 什么是脏读:

A事务读取B事务尚未提交的数据并在此基础上操作，而B事务执行回滚，那么A读取到的数据就是脏读。

2. 什么是不可重复度：

事务A读取前面读取过的数据，发现该数据已经被另一个已提交的事务B修改过了。

3. 什么是幻读：

事务A重新执行一个查询，返回一系列符合查询条件的行，发现其中插入了被事务B提交的行。

4. 第一类丢失更新：

事务A撤销时，把已经提交的事务B的更新数据覆盖了

5. 第二类丢失更新：

事务A覆盖了事务B已经提交的数据，造成事务B所做的操作丢失。

-什么是事务的回滚？

案例：假如一个部门有很多员工，分别在员工表与部门表中，在删除部门表时假设默认删除对应的员工，执行中会出现先删部门再删员工，部门删除了，员工未删除，此时如果删除员工的时候失败了，那么之前的删除的部门也应该删除失败，这就是事务的回滚。

-JDBC中如何进行事务的处理？

Connection提供了事务处理的方法，通过调用setAutoConnection(false)可以设置手动提交事务，当事务完成commit()显示提交事务，如果事务提交过程中发现了异常则进行事务回滚。从JDBC3.0中还引入了Savepoint(保存点）的概念，允许通过代码设置保存点并让事务回滚到指定的保存点。

-连接池

1. 概念

连接池的厂商会一次性创建多个连接，我们只需要去连接池获取连接，当操作完之后归还给连接池即可，连接池会把连接设置为最初的状态（并不是销毁）下一个用户又可以来获取这个连接。

2. 作用

反复来创建连接和销毁连接，提高我们操作数据库的效率，减轻服务器的压力。

3. 常用的连接池

dbcp

特点:  

1. 效率非常高  效率最高

2.可能会丢包(丢失数据)  socket的  udp:  效率高 丢失数据

3.dbcp 一秒创建1000连接

4.dbcp是tomcat（服务器）的内置连接池

使用步骤：

1. 导包（2个）：commons-dbcp-1.4.jar        commons-pool-1.6.jar

 2. 在类的目录下加入配置信息（加载配置文件）

 3. 需要把配置文件的信息，加载到properties里面

 4. 获取连接池对象

c3p0

特点：

1. 安全性高 不会丢失数据  效率低

2. spring 全家桶 才用的连接池 都是使用c3p0  springmvc springboot  springdata

使用步骤:

导包两个：c3p0-0.9.2-pre5.jar      mchange-commons-java-0.2.3.jar

druip(阿里的）

特点：

1. 数据吞吐量大

2. 支持流式数据摄入和实时

3. 查询灵活且快速

Druid是一个分布式数据分析平台，也是一个时序数据库

-自定义连接池

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

public class MyConnectionUtils {
    //获取连接
     private  static   BaseDao baseDao  = new BaseDao();

     //容器来存连接
      private  static List<Connection> list  = new ArrayList<Connection>();


      //来初始化连接

      static {
          for (int i =1;i<=5;i++){
              list.add(baseDao.getConnection());

          }

          System.out.println("当前有"+list.size()+"个连接可以使用");

      }

      //获取连接的方法

      public  static   Connection  getConn(){
          //获取了一个连接
        Connection conn =    list.get(0);
        //当前连接正在使用   请使用其它的连接
        list.remove(0);
          System.out.println("当前有"+list.size()+"当前正在使用的连接是"+conn);
           return  conn;
      }

      //释放连接

      public  static void  close(Connection con){
            if(con !=null){
                  //释放
                 list.add(con);
            }

          System.out.println("现在的连接数是"+list.size());

      }


    public static void main(String[] args) {
        Connection con  =  MyConnectionUtils.getConn();
       // System.out.println(con);

        //释放连接
         MyConnectionUtils.close(con);
    }



}

 -Dbutils框架

dbutils框架 与 hibernate 和 mybatis 框架都是用来操作数据库的。对JDBC的封装，简化开发的步骤，提供了一些类和接口，其中核心的类 QueryRunner()

使用步骤：

1. 导包

2. 得到其核心对象   QueryRunner qr  = new QueryRunner(“参数是连接池的对象”)

代码（增删改查操作）

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.*;
import org.junit.Test;

import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

public class Test3 {
   private ComboPooledDataSource  dataSource  = new ComboPooledDataSource();
    private QueryRunner    qr  = new QueryRunner(dataSource);
     //增加
     @Test
     public  void  add(){
          String sql = "insert into  account(aname,amoney)values(?,?)";
          Object[] objects={"阿力",3000};
         int num  = 0;
         try {
             num = qr.update(sql,objects);
         } catch (SQLException e) {
             e.printStackTrace();
         }
         System.out.println(num);

     }
      //修改
    @Test
    public  void  update(){
        String sql = "update  account  set  aname=?,amoney=? where aid=?";
        Object[] objects={"赵四",10000,3};
        int num  = 0;
        try {
            num = qr.update(sql,objects);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        System.out.println(num);

    }
     //删除
    @Test
    public  void  delete(){
        String sql = "delete  from  account  where aid=?" ;

        int num  = 0;
        try {
            num = qr.update(sql,3);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        System.out.println(num);

    }

    //根据id查询
    @Test
    public  void  seleteById(){
        try {
            String sql = "select  *  from   account  where aid=?" ;
            Account account  =   qr.query(sql,new BeanHandler<Account>(Account.class),1);
            System.out.println(account);
        } catch (SQLException e) {
            e.printStackTrace();
        }


    }

    //查询所有封装到集合中
    @Test
    public  void  selectAll(){
        try {
            String sql = "select  *  from   account" ;
           List<Account> list   =   qr.query(sql,new BeanListHandler<Account>(Account.class));
            for (Account a:list) {
                System.out.println(a);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }


    }
     //查询对象封装到数组中
    @Test
    public  void  seleteByObject(){
        try {
            String sql = "select  * from   account  where aid=?" ;
            Object[] objects  = qr.query(sql,new ArrayHandler(),1);
            for(Object obj :objects){
                System.out.println(obj);
            }

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


    }

    //查询所有封装到集合数组中
    @Test
    public  void  seleteByAll(){
        try {
            String sql = "select  * from   account" ;
            List<Object[]> list  =   qr.query(sql,new ArrayListHandler());
            for(Object[] objects :list){
                System.out.println(Arrays.toString(objects));
            }

           /* for(Object obj :objects){
                System.out.println(obj);
            }
*/
        } catch (SQLException e) {
            e.printStackTrace();
        }


    }


     //查询所有封装到map集合中
    @Test
    public  void  seleteByMap(){
        String sql ="select  * from  account where aid=?";
        try {
            Map<String,Object> map =  qr.query(sql,new MapHandler(),1);
            for(String s:map.keySet()){
                System.out.println(s+"	"+map.get(s));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }


    }


    @Test
    public  void  seleteByAllMap(){
        String sql ="select  * from  account ";
        try {
            List<Map<String,Object>> list   =  qr.query(sql,new MapListHandler());
            for(Map<String,Object> map : list){
                for(String s : map.keySet()){
                    System.out.println(s+"	"+map.get(s));
                }
            }
            /*for(String s:map.keySet()){
                System.out.println(s+"	"+map.get(s));
            }*/
        } catch (SQLException e) {
            e.printStackTrace();
        }


    }

    //查询总计数
    @Test
    public  void  selectCount(){
        try {
            String sql ="select  count(1) from  account ";
            Long  count =   (Long) qr.query(sql,new ScalarHandler());
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        }


    }


}

-分层分包（MVC设计模式）

com.offcn.entity  ==>实体包

com.offcn.dao ==>操作数据库 定义一些方法  都是接口

com.offcn.dao.impl  ==>实现类

com.offcn service ==>逻辑处理  定义一些方法

com.offcn.service.impl  实现层

com.offcn.test ==>定义测试类