Day49-Spring-03 - AOP开发（注解方式）-JDBC模板- 事务管理

最新推荐文章于 2022-08-09 14:55:12 发布

jjizh

最新推荐文章于 2022-08-09 14:55:12 发布

阅读量377

点赞数 1

分类专栏： java学习随记文章标签： spring aop 事务

本文链接：https://blog.csdn.net/jjizh/article/details/77119346

版权

java学习随记专栏收录该内容

47 篇文章 0 订阅

订阅专栏

一、AOP注解（注解方式）

 在Spring02中讲述了xml方式的aop，现在讲解aop的注解形式。

导入jar包
四个基本包
Spring包下：spring-aop-4.2.9.RELEASE.jar，spring-aspects-4.2.9.RELEASE.jar
相关jar包：aopalliance-1.0.jar，aspectjweaver-1.8.9.jar
（和aop的xml方式导入的jar包一样）
导入约束
导入AOP的约束
在xml中打开aop的自动代理开关，同时增强类和业务逻辑类也是必须的
如果是IOC的注解，采用context：component-scan来打开
如果是AOP的注解：采用aop：aspectj-autoproxy

           <bean id="us" class="com.itheima.service.impl.UserServiceImpl" ></bean>
            <bean id="logger" class="com.itheima.util.Logger" ></bean>

           <!--  扫描开关打开有两种：

               如果是IOC的注解， 采用context ： conponent-scan 开关去打开
               如果是AOP的注解 ， 采用aop：    aop:aspectj-autoproxy
           -->

           <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

在增强类中打上注解。

        @Aspect //表示我们这个Logger类是一个切面增强类。 
        public class Logger {

            @Before("execution(* com.itheima.service.*.*(..))")
            public static void log(){
                System.out.println("输出日志了~~");
            }
        }

二、 JDBC模板

Spring 由于所处的位置比较尴尬，刚好处在三层的中间位置。它除了弄好自己的IOC + AOP之外，为了更好的推广自己，让自己的生命力变得更持久，也对持久层的框架做出了支持。说白了，就是包装了dao层的框架代码。让程序员编程效率更高点。

    对持久化框架的支持有以下几个
    如果dao层采用的是JDBC来实现，那么spring会提供 JDBC模板
    如果dao采用的是hibernate来实现，那么spring也会随之提供hibernate模板
    Mybatis也是如此..

1. jdbc模板入门 – 以向数据库插入数据为例子

导入jar包
额外导入三个jar包
spring-jdbc-xxx.jar
spring-tx-xxx.jar （事务的包）
jdbc的驱动包
写代码
如何写这段代码：
只需要记住一个关键的类名：JdbcTemplate即可，后续可以通过这个类，添加响应的dataSource，然后进行插入

        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///user");
        dataSource.setUsername("root");
        dataSource.setPassword("root");

        //1. 创建jdbc模板实例  和dbutils挺像的。 操作数据库，也是两个方法。
        JdbcTemplate jdbcTemplate = new JdbcTemplate();

        //设置数据源
        jdbcTemplate.setDataSource(dataSource);

        String sql = "insert into t_user values (null , ? , ?)";
        jdbcTemplate.update(sql, "admin","admin");

2. jdbc模板 CRUD

jdbc模板针对查询的操作，稍微要注意下即可，需要我们手动封装数据。

insert

       DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///user");
        dataSource.setUsername("root");
        dataSource.setPassword("root");

        //1. 创建jdbc模板实例  和dbutils挺像的。 操作数据库，也是两个方法。
        JdbcTemplate jdbcTemplate = new JdbcTemplate();

        //设置数据源
        jdbcTemplate.setDataSource(dataSource);

        String sql = "insert into t_user values (null , ? , ?)";
        jdbcTemplate.update(sql, "admin","admin");

delete

     @Test
      public void test01(){
           DriverManagerDataSource dataSource = new DriverManagerDataSource();
            //dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://localhost:3306/db_for_test");
           dataSource.setUsername("root");
           dataSource.setPassword("123456");

           JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

           String sql = "delete from user where id = ?";
           jdbcTemplate.update(sql, 6);

      }

update

     @Test
      public void test02(){
           DriverManagerDataSource dataSource = new DriverManagerDataSource();
            //dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://localhost:3306/db_for_test");
           dataSource.setUsername("root");
           dataSource.setPassword("123456");

           JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

           //String sql = "insert into user values(null,?,?)";
           String sql = "update user set address = ? where id = ?";
           jdbcTemplate.update(sql,"地球",5);

      }

查询总条数 - 稍微麻烦一点，功能没有JDBC强，勉强可用
JdbcTemplate这个类进行查询的时候，不会将结果封装成为我们需要的对象，需要我们手动进行封装
查询总记录条数

      @Test
      public void test03(){
           DriverManagerDataSource dataSource = new DriverManagerDataSource();
            //dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://localhost:3306/db_for_test");
           dataSource.setUsername("root");
           dataSource.setPassword("123456");

           JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

           String sql = "select count(*) from user";
           int result = jdbcTemplate.queryForObject(sql, Integer.class);
           System.out.println(result);
      }

查询单个对象

      @Test
      public void test04(){
           DriverManagerDataSource dataSource = new DriverManagerDataSource();
            //dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://localhost:3306/db_for_test");
           dataSource.setUsername("root");
           dataSource.setPassword("123456");

           JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

           String sql = "select * from user where id = ?";
           User result = jdbcTemplate.queryForObject(sql, new MyRowMapper(),5);
           System.out.println(result);
      }

      class MyRowMapper implements RowMapper<User> {
           @Override
           public User mapRow(ResultSet paramResultSet, int paramInt) throws SQLException {
                 int id = paramResultSet.getInt("id");
                 String name = paramResultSet.getString("name");
                 String address = paramResultSet.getString("address");

                 User user = new User();
                 user.setAdd(address);
                 user.setName(name);
                 return user;
           }

      }

查询list集合
为什么不用jdbcTemplate.queryforList()方法呢？因为里面没有RowMapper这个参数

      @Test
      public void test04(){
           DriverManagerDataSource dataSource = new DriverManagerDataSource();
            //dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql://localhost:3306/db_for_test");
           dataSource.setUsername("root");
           dataSource.setPassword("123456");

           JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

           String sql = "select * from user";
           List<User> list= jdbcTemplate.query(sql, new MyRowMapper());
           System.out.println(list);
      }

      class MyRowMapper implements RowMapper<User> {

           @Override
           public User mapRow(ResultSet paramResultSet, int paramInt) throws SQLException {
                 int id = paramResultSet.getInt("id");
                 String name = paramResultSet.getString("name");
                 String address = paramResultSet.getString("address");

                 User user = new User();
                 user.setAdd(address);
                 user.setName(name);
                 return user;
           }

      }

3. jdbc模板注入写法 – 使用测试整合UserService - UserDao - JDBCTemplate - C3p0连接池

导包：
导入Spring四个核心jar包，Spring-jdbc-xx.jar ,Spring-tx-xxx.jar, jdbc驱动， Spring-test-xxx.jar

测试类：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class testSpring模板整合service层和dao层 {

      @Autowired
      private UserService userService;


      @Test
      public void test01(){

           userService.save();
      }

}

service代码

@Service        
public class UserServiceImpl implements UserService {

            private UserDao userDao  ;

            public void setUserDao(UserDao userDao) {
                this.userDao = userDao;
            }

            @Override
            public void save() {
                System.out.println("调用了userServiceImpl的save方法");
                userDao.save();
            }
        }

dao代码

        public class UserDaoImpl implements UserDao {
            private JdbcTemplate jdbcTemplate;
            public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
                this.jdbcTemplate = jdbcTemplate;
            }

            @Override
            public void save() {
                String sql = "insert into t_user values (null , ? , ?)";
                jdbcTemplate.update(sql, "zhangsan","123456");
                System.out.println("保存完毕~");
            }
        }

配置

       <bean id="userService" class="com.itheima.service.impl.UserServiceImpl"
            scope="prototype">
            <property name="userDao" ref="userDao"></property>
        </bean>

        <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
            <!-- ref : 告诉spring要new哪一个类给注入进去 要想表示这个类， 得声明一个bean -->
            <property name="jdbcTemplate" ref="jt"></property>
        </bean>


        <bean id="jt" class="org.springframework.jdbc.core.JdbcTemplate">
            <property name="dataSource" ref="ds"></property>
        </bean>

        <bean id="ds" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
            <property name="url" value="jdbc:mysql:///user"></property>
            <property name="username" value="root"></property>
            <property name="password" value="root"></property>
        </bean>

4. jdbc模板关联c3p0连接池

优化使用：使用c3p0来优化上面案例的模板的使用

代码不用改动，只要改动注入的数据源即可
首先导入c3p0连接池的jar包
配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
      <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
      <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
      <property name="dataSource" ref="dataSource"></property>
    </bean>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
      <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
      <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/db_for_test"></property>
      <property name="user" value="root"></property>
      <property name="password" value="123456"></property>
    </bean>


    <context:component-scan base-package="com.itheima"></context:component-scan>

</beans>

三、事务

什么是事务

事务其实就是用来包装一组逻辑，控制逻辑的整体结果。如果这一组逻辑里面有一个动作执行失败，那么整组的结果就以失败告终。（回滚事务），如果这一组逻辑里面运行都成功了，那么就认为成功（提交事务）

事务特性

ACID 原子性、一致性、隔离性、持久性
事务如果不考虑隔离会出现以下问题
- 读问题
  脏读
  不可重复读
  虚读|幻读
  
  隔离级别：
  读未提交
  读已提交 : Oracle
  可重复读： Mysql
  序列化|串行化
- 写问题
  丢失更新
  两个事务同时操作。不管后面的那个事务是提交还是回滚，都将让前一个事务提交的结果，失效。丢失。
  
  乐观锁
  认为不会出现丢失更新，要在表里面加一个字段，自己维护。
  悲观锁
  还没开始做，就认为一定会丢失更新。
  在开始操作之前，先执行查询 for update

1. 编程式

导包：
Spring-jdbc-XXX.jar
Spring-tx-xxx.jar
当然还有jdbc驱动包
主要的类就是TransactionTemplate和JdbcTemplate

        @Test
        public void testDemo(){
            DriverManagerDataSource dataSource = new DriverManagerDataSource();
            dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            dataSource.setUrl("jdbc:mysql:///user");
            dataSource.setUsername("root");
            dataSource.setPassword("root");


            //定义事务的管理者
            DataSourceTransactionManager transactionManager  =  new DataSourceTransactionManager(dataSource);

            //创建事务的模板
            TransactionTemplate transactionTemplate = new TransactionTemplate();
            //设置事务的管理者是谁。一定要设置管理者，否则无法使用事务。
            transactionTemplate.setTransactionManager(transactionManager);


            final JdbcTemplate jdbcTemplate = new JdbcTemplate();
            jdbcTemplate.setDataSource(dataSource);

            //设置回调，也就是在里面写我们真正要操作的 crud逻辑
            transactionTemplate.execute(new TransactionCallback<Object>() {

                @Override
                public Object doInTransaction(TransactionStatus arg0) {

                    try {
                        //在这里面写 crud代码。 这个doInTransaction 方法会被spring的框架所调用。
                        //它在底下开启完事务之后，就用这个方法。

                        String sql = "insert into t_user values (null , ? , ?)";
                        jdbcTemplate.update(sql , "aobama2","6666222");

                        int a = 10 / 0 ;
                    } catch (DataAccessException e) {
                        e.printStackTrace();

                        //设置回滚的标记。
                        arg0.setRollbackOnly();
                    }
                    return null;
                }
            });
        }

2. 声明式 - XML

导入jar包
Spring-jdbc-XXX.jar
Spring-tx-xxx.jar
当然还有jdbc驱动包
导入约束
aop \ tx \bean 约束
配置事务
可以看出，事务的本质也是进行了aop的增强，在前面加上了事务的开启，后面加上了事务的提交和回滚

        <!-- 以下是配置事务  事务的配置，其实就是AOP的操作。 -->
        <!-- 1. 声明事务的建议  会对哪一个方法进行事务啊。 就是在这里进行配置-->
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="ds"></property>
        </bean>



        <tx:advice id="advice" transaction-manager="transactionManager">
            <!-- 这个tx:attributes 就是用来控制到底给哪个方法加入事务 -->
            <tx:attributes>
                <!-- * 表示给前面找到的所有方法都应用事务  dao ==== jdbctemplate    hibernatetemplate-->
                <tx:method name="*"/>
            </tx:attributes>
        </tx:advice>



        <!-- 还少一件事情， 对哪些类的，哪些方法，进行事务。 -->
        <aop:config>
            <aop:pointcut expression="execution(* com.itheima.service.*.*(..))" id="pointCut"/>

            <!-- 给上面的pointCut 切入点，找到的方法，应用上面给出的事务建议。也就是给这些方法，都是用事务来管理 -->
            <aop:advisor advice-ref="advice" pointcut-ref="pointCut"/>
        </aop:config>

3. 声明式 - 注解（重要 - 最常用的方式）

在xml里面指定事务使用的管理者是谁

         <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"></property>
        </bean>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
      <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
      <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/db_for_test"></property>
      <property name="user" value="root"></property>
      <property name="password" value="123456"></property>
    </bean>

         <!-- 打开注解开关  这里是指定注解的事务，采用什么管理者。 光有那个类上的注解，是不够的，因为spring
         也不知道我们打算使用什么类型的管理者来操作事务。 -->
         <tx:annotation-driven transaction-manager="transactionManager"/>

2. 在业务逻辑类上面打上注解 ，当然如果想指定具体的某一个方法采用事务，也可以在方法上面打上注解


public class UserDaoImpl implements UserDao {

      private JdbcTemplate jdbcTemplate;
      public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
           this.jdbcTemplate = jdbcTemplate;
      }

      @Override
      @Transactional
      public void save() {
           System.out.println("userDao的save方法执行了");
           String sql = "insert into user values(null,?,?)";
           jdbcTemplate.update(sql, "测试1","测试1");
           int i= 10/0;
           jdbcTemplate.update(sql, "测试2","测试2");
           System.out.println("保存成功");
      }

}