JAVA-Spring 整合 JDBC

一、回顾JDBC

　　　1.java操作关系型数据的API。

　　　　　导入相关数据库的驱动包后可以通过JDBC提供的接口来操作数据库。

　　　2.实现JDBC的六个步骤

　　　　　　注册数据库驱动

　　　　　　获取数据库连接

　　　　　　获取传输器对象

　　　　　　传输sql执行获取结果集对象

　　　　　　遍历结果集获取信息

　　　　　　关闭资源

　　　　

            package cn.tedu.jdbc;
            
            import java.sql.Connection;
            import java.sql.DriverManager;
            import java.sql.PreparedStatement;
            import java.sql.ResultSet;
            import java.sql.SQLException;
            
            
            /**
                    create database springdb;
                    use springdb;
                    create table stu(id int primary key auto_increment,name varchar(255),addr varchar(255));
                    insert into stu values (null,'aaa','bj'),(null,'bbb','sh'),(null,'ccc','gz'),(null,'ddd','sh'),(null,'eee','bj');
             */
            public class Demo01 {
                    public static void main(String[] args){
                            Connection conn = null;
                            PreparedStatement ps = null;
                            ResultSet rs = null;
                            try {
                                    //1.注册数据库驱动
                                    Class.forName("com.mysql.jdbc.Driver");
                                    //2.获取数据库连接
                                    conn = DriverManager.getConnection("jdbc:mysql:///springdb","root","root");
                                    //3.获取传输器
                                    ps = conn.prepareStatement("select * from stu where id < ?");
                                    ps.setInt(1, 4);
                                    //4.执行sql获取结果集
                                    rs = ps.executeQuery();
                                    //5.遍历结果集获取结果
                                    while(rs.next()){
                                            String name = rs.getString("name");
                                            System.out.println(name);
                                    }
                            } catch (Exception e) {
                                    e.printStackTrace();
                            } finally {
                                    //6.关闭资源
                                    if(rs!=null){
                                            try {
                                                    rs.close();
                                            } catch (SQLException e) {
                                                    e.printStackTrace();
                                            } finally{
                                                    rs = null;
                                            }
                                    }
                                    if(ps!=null){
                                            try {
                                                    ps.close();
                                            } catch (SQLException e) {
                                                    e.printStackTrace();
                                            } finally{
                                                    ps = null;
                                            }
                                    }
                                    if(conn!=null){
                                            try {
                                                    conn.close();
                                            } catch (SQLException e) {
                                                    e.printStackTrace();
                                            } finally{
                                                    conn = null;
                                            }
                                    }
                            }
                            
                    }
            }

　　3.数据库连接池（数据源）

　　　　C3P0连接池

　　

            package cn.tedu.jdbc;
            
            import java.beans.PropertyVetoException;
            import java.sql.Connection;
            import java.sql.PreparedStatement;
            import java.sql.ResultSet;
            import java.sql.SQLException;
            
            import com.mchange.v2.c3p0.ComboPooledDataSource;
            
            
            /**
                    create database springdb;
                    use springdb;
                    create table stu(id int primary key auto_increment,name varchar(255),addr varchar(255));
                    insert into stu values (null,'aaa','bj'),(null,'bbb','sh'),(null,'ccc','gz'),(null,'ddd','sh'),(null,'eee','bj');
             */
            public class Demo02 {
                    private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
                    static{
                            try {
                                    dataSource.setDriverClass("com.mysql.jdbc.Driver");
                                    dataSource.setJdbcUrl("jdbc:mysql:///springdb");
                                    dataSource.setUser("root");
                                    dataSource.setPassword("root");
                            } catch (PropertyVetoException e) {
                                    e.printStackTrace();
                                    throw new RuntimeException(e);
                            }
                    }
                    
                    public static void main(String[] args){
                            Connection conn = null;
                            PreparedStatement ps = null;
                            ResultSet rs = null;
                            try {
                                    //1.2.从数据源中获取连接
                                    conn = dataSource.getConnection();
                                    //3.获取传输器
                                    ps = conn.prepareStatement("select * from stu where id < ?");
                                    ps.setInt(1, 4);
                                    //4.执行sql获取结果集
                                    rs = ps.executeQuery();
                                    //5.遍历结果集获取结果
                                    while(rs.next()){
                                            String name = rs.getString("name");
                                            System.out.println(name);
                                    }
                            } catch (Exception e) {
                                    e.printStackTrace();
                            } finally {
                                    //6.关闭资源
                                    if(rs!=null){
                                            try {
                                                    rs.close();
                                            } catch (SQLException e) {
                                                    e.printStackTrace();
                                            } finally{
                                                    rs = null;
                                            }
                                    }
                                    if(ps!=null){
                                            try {
                                                    ps.close();
                                            } catch (SQLException e) {
                                                    e.printStackTrace();
                                            } finally{
                                                    ps = null;
                                            }
                                    }
                                    if(conn!=null){
                                            try {
                                                    conn.close();
                                            } catch (SQLException e) {
                                                    e.printStackTrace();
                                            } finally{
                                                    conn = null;
                                            }
                                    }
                            }
                            
                    }
            }

 

二、整合JDBC - 管理数据源

　　1.导入相关开发包

　　

 

 

　　2.将数据源交于Spring管理

 

 

　　3.通过Spring获取数据源，获取连接，操作数据库

 

三、Spring整合JDBC - JDBC 模板类

　　　　使用模板类能够极大的简化原有JDBC的编程过程。

　　a.在Spring中配置JDBC模板类

　　　　

　　b.使用JDBC模板类实现增删改查

            /**
                     * 使用jdbc模板类 实现 delete
                     */
                    @Test
                    public void test06(){
                            JdbcTemplate jdbcTemplate = (JdbcTemplate) context.getBean("jdbcTemplate");
                            int count = jdbcTemplate.update("delete from stu where id = ?",4);
                            System.out.println("执行成功，影响到的行数为"+count);
                    }
                    
                    /**
                     * 使用jdbc模板类 实现 insert
                     */
                    @Test
                    public void test05(){
                            JdbcTemplate jdbcTemplate = (JdbcTemplate) context.getBean("jdbcTemplate");
                            int count = jdbcTemplate.update("insert into stu values (null,?,?)","fff","gz");
                            System.out.println("执行成功，影响到的行数为"+count);
                    }
                    
                    
                    /**
                     * 使用jdbc模板类 实现 update
                     */
                    @Test
                    public void test04(){
                            JdbcTemplate jdbcTemplate = (JdbcTemplate) context.getBean("jdbcTemplate");
                            int count = jdbcTemplate.update("update stu set addr = ? where  id = ?", "sz",3);
                            System.out.println("执行成功，影响到的行数为"+count);
                    }
                    
                    /**
                     * 使用jdbc模板类 实现 query
                     */
                    @Test
                    public void test03(){
                            JdbcTemplate jdbcTemplate = (JdbcTemplate) context.getBean("jdbcTemplate");
                            SqlRowSet rs = jdbcTemplate.queryForRowSet("select * from stu where id < ?" ,4);
                            while(rs.next()){
                                    String name = rs.getString("name");
                                    System.out.println(name);
                            }
                    }
                    
                    /**
                     * 使用jdbc模板类 实现 query
                     */
                    @Test
                    public void test02(){
                            JdbcTemplate jdbcTemplate = (JdbcTemplate) context.getBean("jdbcTemplate");
                            List<Map<String,Object>> list = jdbcTemplate.queryForList("select * from stu where id < ?",4);
                            System.out.println(list);
                    }

3.使用RowMapper封装bean

　　　RowMapper接口定义了对象到列的映射关系，可以帮助我们在查询时自动封装bean。

                package cn.tedu.spring.domain;
                
                import java.sql.ResultSet;
                import java.sql.SQLException;
                
                import org.springframework.jdbc.core.RowMapper;
                
                public class UserRowMapper implements RowMapper<User> {
                
                        @Override
                        public User mapRow(ResultSet rs, int rowNum) throws SQLException {
                                User user = new User();
                                user.setId(rs.getInt(1));
                                user.setName(rs.getString(2));
                                user.setAddr(rs.getString(3));
                                return user;
                        }
                
                }

/** 2 * 使用jdbc模板类 使用RowMapper 3 */ 4 @Test 5 public void test08(){ 6 JdbcTemplate jdbcTemplate = (JdbcTemplate) context.getBean("jdbcTemplate"); 7 User user = jdbcTemplate.queryForObject("select * from stu where id = ?",new UserRowMapper() ,2); 8 System.out.println(user); 9 } 10 /** 11 * 使用jdbc模板类 实现单条query 12 */ 13 @Test 14 public void test09(){ 15 JdbcTemplate jdbcTemplate = (JdbcTemplate) context.getBean("jdbcTemplate"); 16 List<User> list = jdbcTemplate.query("select * from stu", new UserRowMapper()); 17 System.out.println(list); 18 }

　　4.使用BeanPropertyRowMapper自动进行映射

　　　　BeanPropertyRowMapper内部可以指定类进行反射（内省）来获知类内部的属性信息，自动映射到表的列。使用它一定要注意，类的属性名要和对应表的列名必须对应的上，否则属性无法自动映射。BeanPropertyRowMapper底层通过反射（内省）来实现，相对于之前自己写的RowwMapper效率比较低。

　　

                /**
                 * 使用jdbc模板类 实现单条query
                 */
                @Test
                public void test10(){
                        JdbcTemplate jdbcTemplate = (JdbcTemplate) context.getBean("jdbcTemplate");
                        List<User> list = jdbcTemplate.query(
                                "select * from stu", 
                                        new BeanPropertyRowMapper(User.class));
                        System.out.println(list);
                }

四、Spring整合JDBC - 声明式事务处理

　　　　Spring中提供了内置的事务处理机制，称之为声明式事务处理。

　　1.创建项目，模拟MVC三层架构

　　2.在配置文件中导入相关约束

　　　　

　　3.配置事务管理器

　　　　

　　4.配置事务切面

　　

　  5.配置事务通知

　　　

　  6.配置关系图

　　

　  7.事务管理策略

　　　　异常的种类：

　　　　　　　java.lang.Throwable

　　　　　　　　　　|-Exception

　　　　　　　　　　　　|-RuntimeException

　　　　　　　　　　　　|-其他Exception

　　　　　　　　　　|-Error

　　　　spring内置的事务策略，只在底层抛出的异常是运行时异常时，才会回滚，其他异常不回滚，留给用户手动处理。

　　　　也可以在配置中指定在原有规则的基础上，哪些异常额外回滚或不回滚：

　　　　

　　　　配置成如下形式，可以实现任意异常都自动回滚：

　　　　

8.注意：如果在一个业务逻辑中，需要有多步不同表的操作，此时应该在service层完成对不同表的操作，一次保证多步操作处于同一个事务中，切勿将业务代码在web层中调用Service来实现，虽然正常情况下也可以完成功能，但一旦出问题，很可能只有部分操作回滚，数据出现问题。

　　　　出现这种问题，不是事务管理机制的问题，而是开发者将业务逻辑错误的在web层中进行了实现，所以切记，web层只负责和用户交互和业务逻辑的调用，不进行任何业务逻辑的处理，任何业务逻辑都在service层中进行。

五、声明式事务处理 - 注解方式

　　1.开启事务注解配置

　　　　

　　2.在方法上通过注解开启事务

　　　　即可以标注在接口上，也可以标注在实现类上，理论上应该表在接口上，实现面向接口编程，但实际开发中为了方便也有人写在实现类上。

　　　　

　　　　也可以在类上使用此接口，此时类中所有方法都会有事务

　　　　

　　　　当在类上开启了事务后，可以此类的方法中使用如下方法，控制某个方法没有事务

　　　　

　　　　通过注解控制事务时，和配置文件方式控制事务相同的是，默认只有运行时异常才会回滚，非运行时异常不回滚，此时可以通过如下注解选项额外配置 ，哪些异常需要回滚，哪些不需要。

　　

六、扩展案例

　　**扩展案例：缓存的使用 - 通过AOP实现为查询操作增加缓存机制

　　

            @Component
            @Aspect
            public class CatchAspect {
                /**
                 * 使用Map实现的缓存
                 *     只会增加不会减少
                 *     没有超时时间，不管过了多久都使用历史缓存
                 *     没有存储优化
                 */
                private Map<Integer,User> map = new HashMap<Integer,User>();
                
                @Around("execution(* cn.tedu.spring.service.*.queryUser(..))")
                public User around(ProceedingJoinPoint jp) throws Throwable{
                    int i = (Integer) jp.getArgs()[0];
                    if(map.containsKey(i)){
                        System.out.println("使用缓存查询。。。");
                        //有缓存
                        return map.get(i);
                    }else{
                        System.out.println("使用数据库查询。。。");
                        //没缓存
                        User user = (User) jp.proceed();
                        map.put(user.getId(), user);
                        return user;
                    }
                }
            }