Spring知识复习之三

Spring整合JDBC

1 Spring提供了很多持久层技术模板类

ORM持久化技术 模板类

       JDBC                             org.springframework.jdbc.core.JdbcTemplate
       Hibernate3.0             org.springframework.orm.hibernate3.HibernateTemplate
       IBatis(MyBatis)          org.springframework.orm.ibatis.SqlMapClientTemplate
       JPA                              org.springframework.orm.jpa.JpaTemplate

2 Spring与Jdbc

(1)原生JDBC模板
<1>连接池的使用
                1.使用C3p0连接池(com.mchange.v2.c3p0.ComboPooledDataSource)
                代码示例如下：
                    ComboPooledDataSource dataSource=new ComboPooledDataSource();
                    dataSource.setDriverClass("com.mysql.jdbc.Driver");
                    dataSource.setJdbcUrl("jdbc:mysql:///hibernate_crm");
                    dataSource.setUser("root");
                    dataSource.setPassword("root");
                2.使用spring内置连接池(org.springframework.jdbc.datasource.DriverManagerDataSource)
                代码示例如下：
                    DriverManagerDataSource dataSource=new DriverManagerDataSource();
                    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
                    dataSource.setUrl("jdbc:mysql:///hibernate_crm");
                    dataSource.setUsername("root");
                    dataSource.setPassword("root");
    <2>JDBC模板对象的调用
                    //1 创建JDBC模板对象
                    JdbcTemplate jt=new JdbcTemplate();
                    //2连接进连接池
                    jt.setDataSource(dataSource);
                    //3 书写sql语句,并执行
                    String sql="insert into t_user values(null,'rose')";
                    jt.update(sql);
(2)Spring对连接池进行管理
                <1>配置Spring内置的连接池DriverManagerDataSource
                        <bean name="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
                                <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
                                <property name="url" value="jdbc:mysql:///hibernate_crm"></property>
                                <property name="username" value="root"></property>
                                <property name="password" value="root"></property>
                        </bean>
                        <!--配置JDBCTemplate对象并关联Spring内置的连接池  -->
                        <bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
                            <property name="dataSource" ref="dataSource"></property>
                        </bean>
                <2>配置C3P0连接池
                         导入jar包:    com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar
                        <bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
                            <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
                            <property name="jdbcUrl" value="jdbc:mysql:///hibernate_crm"></property>
                            <property name="user" value="root"></property>
                            <property name="password" value="root"></property>
                        </bean>
                        <!--配置JDBCTemplate对象并关联C3p0连接池 -->
                        <bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
                            <property name="dataSource" ref="dataSource"></property>
                        </bean>
                <3>配置db连接池
                        导入jar包: 
                                com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jar
                                com.springsource.org.apache.commons.pool-1.5.3.jar
                                <!-- 配置 DBCP 连接池 -->
                                <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
                                <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
                                <property name="url" value="jdbc:mysql:///spring_day02"/>
                                <property name="username" value="root"/>
                                <property name="password" value="123"/>
                                </bean>
(3)JdbcTemplate对象的增删改查
            概述：JdbcTemplate的增删改都使用  update()方法。而查询则使用queryForObject()
            //增
            @Override
            public void save(User u) {
                String sql="insert into t_user values(null,?)";
                jt.update(sql,u.getName());
            }
            //删(根据id删除)
            @Override
            public void delete(Integer id) {
                String sql="delete from t_user where id=?";
                jt.update(sql,id);
            }
            //改
            @Override
            public void update(User u) {
                String sql="update t_user set name=? where id=?";
                jt.update(sql,u.getName(),u.getId());
            }
            //查(根据id进行查询,获取一个对象)
            @Override
            public User getById(Integer id) {
                String sql="select * from t_user where id=?";
                User user = jt.queryForObject(sql, new RowMapper<User>() {
                    @Override
                    public User mapRow(ResultSet rs, int arg1) throws SQLException {
                        //封装实体 User对象返回给这个方法
                        User u=new User();
                        u.setId(rs.getInt("id"));
                        u.setName(rs.getString("name"));
                        return u;
                    }},id);
                return user;
            }
            //查(查询表中总共有几条记录)
            @Override
            public int getTotalCount() {
                String sql="select count(*) from t_user";
                Integer count = jt.queryForObject(sql,Integer.class);
                return count;
            }
            //查(查询获取表中的所以记录对象,获取的是集合对象)
            @Override
            public List<User> getAll() {
                String sql="select * from t_user";
                List<User> userList = jt.query(sql, new RowMapper<User>(){
                    @Override
                    public User mapRow(ResultSet rs, int arg1) throws SQLException {
                        User user=new User();
                        user.setId(rs.getInt("id"));
                        user.setName(rs.getString("name"));
                        return user;
                    }});
                return userList;
            }
(4)将数据库信息配置到属性文件中
            <1>在src下创建一个配置文件，如 jdbc.properties
                     内容如下：
                        jdbc.driverClass=com.mysql.jdbc.Driver
                    jdbc.url=jdbc:mysql:///spring_crm
                    jdbc.username=root
                    jdbc.password=123
            <2>在applicationContext主配置文件中
                    方式一：
                    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
                    <property name="location" value="classpath:jdbc.properties"/>
                    </bean>
                    方式二：
                    <context:property-placeholder location="classpath:jdbc.properties"/>

Spring事务管理

1事务回顾

        <1>什么是事务:
                事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败.
        <2>事务特性:
                原子性 :强调事务的不可分割.
                一致性 :事务的执行的前后数据的完整性保持一致.
                隔离性 :一个事务执行的过程中,不应该受到其他事务的干扰
                持久性 :事务一旦结束,数据就持久到数据库
        <3>如果不考虑隔离性引发安全性问题:
                脏读  :一个事务读到了另一个事务的未提交的数据
                不可重复读 :一个事务读到了另一个事务已经提交的 update 的数据导致多次查询结果不一致.
                虚幻读 :一个事务读到了另一个事务已经提交的 insert 的数据导致多次查询结果不一致.
        <4>解决读问题: 设置事务隔离级别
                未提交读  :脏读，不可重复读，虚读都有可能发生
                已提交读  :避免脏读。但是不可重复读和虚读有可能发生
                可重复读  :避免脏读和不可重复读.但是虚读有可能发生.
                串行化的  :避免以上所有读问题.
        <5>
                Mysql 默认:可重复读
                Oracle 默认:读已提交          

2 相关的API接口

(1) 平台事务管理器 PlatformTransactionManager
    <1> org.springframework.jdbc.datasource.DataSourceTransactionManager  
          SpringJDBC  或 iBatis 使用
    <2> org.springframework.orm.hibernate3.HibernateTransactionManager
          Hibernate 进行持久化数据时使用
(2)事务定义信息接口 TransactionDefinition 
     事务定义信息内容包括：
        * 隔离级别
        * 传播行为 
                    事务的传播的格式为：PROPAGION_XXX  
                    & 保证同一个事务中
                            PROPAGATION_REQUIRED 支持当前事务，如果不存在 就新建一个(默认)
                            PROPAGATION_SUPPORTS 支持当前事务，如果不存在，就不使用事务
                            PROPAGATION_MANDATORY  支持当前事务，如果不存在，抛出异常
                    & 保证不在同一个事务中
                            PROPAGATION_REQUIRES_NEW  如果有事务存在，挂起当前事务，创建一个新的事务
                            PROPAGATION_NOT_SUPPORTED  以非事务方式运行，如果有事务存在，挂起当前事务
                            PROPAGATION_NEVER 以非事务方式运行，如果有事务存在，抛出异常
                            PROPAGATION_NESTED 如果当前事务存在，则嵌套事务执行
        * 超时信息
        * 是否只读
(3) 事务状态接口 TransactionStatus,记录事务的状态

2 Spring事务管理过程简述

平台事务管理器(PlatformTransactionManager)  
根据  事务定义的信息(TransactionDefinition ) 
将事务管理过程中的状态记录到  TransactionStatus里面

3 Spring事务管理分类

(1)传统的事务管理方式：编程式事务方式(手动编写代码完成事务的管理)
     <1> Jdbc相关代码示例：
            (Connection) conn.setAutoCommit(false);  //设置手动管理事务
    <2>Hibernate相关代码示例：
            Session.beginTransaction();
    <3>特点分析：
        优点：细粒度的事务控制，可以对指定方法，或指定方法的某几行进行事务控制。
        缺点：虽灵活，但繁琐，每次要开启 ，提交，回滚，且要释放资源，否则耗内存。
(2)Spring提供对事务的管理，这就叫做声明式事务管理。
    <1>声明式事务管理特点：
            粗粒度的事务控制，只能给整个方法应用事务，不可以对方法的某几行应用事务。
            其核心是基于 AOP的。
    <2>Spring声明式事务管理器分类：
        Jdbc技术：DataSourceTransactionManager
        Hibernate技术：HibernateTransactionManager
    <3>xml声明式事务管理配置如下：
        《1》<!--配置spring的事务核心管理器,封装了所有事务操作,依赖于连接池 -->
        <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager ">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
        《2》<!--配置spring事务模板对象,用于service层代码API调用,依赖于spring的事务核心管理器  -->
        <bean name="transcationTemplate" class="org.springframework.transaction.support.TransactionTemplate">
            <property name="transactionManager" ref="transactionManager"></property>
        </bean>
        《3》将spring事务模板对象 依赖到service层中
        <bean name="accountService" class="cn.sss.service.AccountServiceImp">
            <property name="ad" ref="accountDao"></property>
            <property name="tt" ref="transcationTemplate"></property>
        </bean>
        《4》<!-- 配置事务通知 ,依赖spring事务核心管理器-->
        <tx:advice transaction-manager="transactionManager" id="txAdvice">
            <tx:attributes>
                <!--以方法为单位,指定方法应用什么事务属性  
                        name:要进行事务管理 的方法名
                        isolation：设置事务的隔离级别
                        propagation:事务的传播行为
                        read-only:只读
                  -->
                <tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
                <!--下面为企业中的事务管理 的方法配置(使用通配符 *)  -->
                <tx:method name="persist*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
                <tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
                <tx:method name="modify*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
                <tx:method name="delete*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
                <tx:method name="remove*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
                <tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true"/>
                <tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true"/>
                <tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
                <tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
                <tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
            </tx:attributes>
        </tx:advice>
        《5》<!--配置织入(把事务通知织入到目标对象中)  -->
                <aop:config>
                    <!--配置切点(需增强的方法)  -->
                    <aop:pointcut expression="execution(* cn.itheima.service.*ServiceImp.*(..))" id="txPc"/>
                    <!-- 配置切面(切点+通知)
                        advice-ref:通知名称
                        pointcut-ref:切点名称
                     -->
                    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPc"/>
                </aop:config>

<4>注解 实现spring声明式事务管理
    * 主配置文件为：
        <!--配置spring的事务核心管理器,封装了所有事务操作,依赖于连接池 -->
        <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager ">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
        <!--配置spring事务模板对象,依赖于spring的事务核心管理器  -->
        <bean name="transcationTemplate" class="org.springframework.transaction.support.TransactionTemplate">
            <property name="transactionManager" ref="transactionManager"></property>
        </bean>
        <!--开启使用注解管理aop事务  -->
        <tx:annotation-driven/>
    * 业务service层:
        & 在类上方使用注解  注入aop事务管理的配置,作用于整个类中所有的方法
        @Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=false)
        public class AccountServiceImp implements AccountService {}
        & 在方法名前使用注解配置aop事务(作用于此方法,权限大于在类上写入的注解)
        @Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=false)
        public void transfer(Integer from, Integer to, Double money) {}