AOP

aop:面向切面编程，通过预编译和运行期动态代理，实现在不修改程序源代码的基础上统一动态和给程序添加某些功能的技术。

相关术语

通知（advice）：代理对象的方法。分为前置通知，最终通知，返回通知，异常通知，环绕通知五类。以反射执行目标对象方法为基准：

  • 前置通知：在目标对象方法执行之前执行；
  • 最终通知：在目标对象方法执行完成后，无论在执行过程中是否出现异常，都会执行；
  • 异常通知：目标对象方法执行过程中产生异常后执行；
  • 返回通知：目标对象方法执行过程中不产生异常时执行；

  • 环绕通知：特殊的通知，不以目标对象方法为基准，可以同时实现前置和后置通知。环绕通知保留了调度目标对象原有方法的功能，也就是说，使用环绕通知甚至可以不必要调用目标对象方法，可以取代目标对象的方法。因此环绕通知非常强大，而且灵活，但可控性差，一般不需要大量改变业务逻辑的情况下，不会使用环绕通知。

    1.   **织入（weaving）**：将通知组合到目标的过程。<br />        **连接点（join point）**：能被代理对象增强的方法。<br />        **切入点（pointcut）**：真正被增强的方法。<br />        注意：只有被切入点表达式匹配的连接点，才能成为切入点。切入点一定是连接点，而连接点不一定是切入点，因为连接点有可能不需要进行增强。<br />        **切面（aspect）**：通知与切点的结合。

XML实现AOP

1.导入依赖

  1.                 <dependency>
  2.             <groupId>org.springframework</groupId>
  3.             <artifactId>spring-context</artifactId>
  4.             <version>5.2.8.RELEASE</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.aspectj</groupId>
  8.             <artifactId>aspectjweaver</artifactId>
  9.             <version>1.8.7</version>
  10.         </dependency>

2.编写通知类

  1. package com.woniuxy.interceptor;
  3. import org.aspectj.lang.annotation.*;
  4. import org.springframework.stereotype.Component;
  6. /**
  7.  * 进行事务管理的类
  8.  */
  10. public class TransactionManager {
  13.     public void beginTransaction(){
  14.         System.out.println("开启事务");
  15.     }
  17.     public void commit(){
  18.         System.out.println("提交事务");
  19.     }
  21.     public void rollback(){
  22.         System.out.println("回滚事务");
  23.     }
  25.     public void close() {
  26.         System.out.println("释放资源");
  27.     }
  28. }

3.编写核心配置文件（引入AOP命名空间）

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd
  7.        http://www.springframework.org/schema/aop
  8.        http://www.springframework.org/schema/aop/spring-aop.xsd
  9. ">
  10.         <!---->
  11.     <bean id="userService" class="com.woniuxy.service.impl.UserServiceImpl"/>
  12.     <!--配置通知-->
  13.     <bean id="transactionManager" class="com.woniuxy.interceptor.TransactionManager"></bean>
  14.     <!--aop相关的配置-->
  15.     <aop:config>
  16.         <!--
  17.             配置切入点
  18.             访问修饰符 方法返回值  方法名（参数列表）
  19.         -->
  20.         <aop:pointcut id="pointCut" expression="execution(* com.woniuxy.service.impl.*.*(..))"/>
  21.         <!--配置切面-->
  22.         <aop:aspect ref="transactionManager">
  23.             <aop:before method="beginTransaction" pointcut="execution(* com.woniuxy.service.impl.*.*(..))"/>
  24.             <aop:after-returning method="commit" pointcut-ref="pointCut"/>
  25.             <aop:after-throwing method="rollback" pointcut-ref="pointCut"/>
  26.             <aop:after method="close" pointcut-ref="pointCut"/>
  27.         </aop:aspect>
  28.     </aop:config>
  30. </beans>

注解实现AOP

1.导入依赖

2.创建配置类

  1. @Configuration
  2. @EnableAspectJAutoProxy
  3. @ComponentScan(basePackages = {"com.woniuxy"})
  4. public class ApplicationConfig {
  5. }

3.修改通知类

  1. /**
  2.  * 进行事务管理的类
  3.  */
  4. @Component
  5. @Aspect
  6. public class TransactionManager {
  8.     @Pointcut("execution(* com.woniuxy.service.impl.*.*(..))")
  9.     public void pointCut(){}
  12.     @Before("pointCut()")//前置通知
  13.     public void beginTransaction(){
  14.         System.out.println("开启事务");
  15.     }
  17.     @AfterReturning("pointCut()")//返回通知
  18.     public void commit(){
  19.         System.out.println("提交事务");
  20.     }
  22.     @AfterThrowing("pointCut()")//异常通知
  23.     public void rollback(){
  24.         System.out.println("回滚事务");
  25.     }
  27.     @After("pointCut()")//最终通知
  28.     public void close() {
  29.         System.out.println("释放资源");
  30.     }
  31. }

QueryRunner

使用queryRunner解决对象引用的问题

1、导入依赖 commons-dbutils

  1.         <dependency>
  2.             <groupId>commons-dbutils</groupId>
  3.             <artifactId>commons-dbutils</artifactId>
  4.             <version>1.6</version>
  5.         </dependency>

2、将queryrunner对象交由容器管理

  1.  @Bean//通过Bean注解将QueryRunner添加进spring容器
  2.     public QueryRunner queryRunner(){
  3.         return new QueryRunner();
  4.     }

3、dao层注入queryrunner，并使用该对象进行增删改查

  1. @Repository("accountDao")//控制层注解
  2. public class AccountDaoImpl implements AccountDao {
  3.     //使用一个工具QueryRunner  commons-dbutils
  4.     //JdbcTemplate  也可以操作数据库
  6.     @Resource//属性注入
  7.     private ConnectionUtil connectionUtil;
  8.     @Resource
  9.     private QueryRunner queryRunner;
  11.     @Override
  12.     public Account findByUsername(String username) throws SQLException {
  14.         //参数1：数据库连接  参数2：要执行的sql语句  参数3：查询结果使用哪种类型进行封装  参数4：sql语句执行时，需要填充的参数
  15.         //query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params)
  16.         Account account = queryRunner.query(connectionUtil.getConnection(),
  17.                 "select * from account where username=?",
  18.                 new BeanHandler<Account>(Account.class), username);
  20.         return account;
  21.     }
  23.     @Override
  24.     public int updateAccount(Account account) throws SQLException {
  26.         int i = queryRunner.update(connectionUtil.getConnection(),
  27.                 "update account set balance=? where username=?",
  28.                 account.getBalance(), account.getUsername());
  29.         return i;
  30.     }
  31. }

环绕通知

通过环绕通知可以解决spring5.2.6及以下版本中，使用注解实现aop时出现通知执行顺序问题（前置->最终->返回或异常），5.2.7版本及以上，这个bug已被修复。

  1. @Component
  2. @Aspect
  3. public class TransactionManager {
  4.     //真正的去完成事务控制，不能再使用伪代码
  5.     @Resource
  6.     private ConnectionUtil connectionUtil;
  7.     @Pointcut("execution(* com.woniuxy.service.impl.*.*(..))")
  8.     public void pointCut(){}
  10. //    @Before("pointCut()")
  11.     public void beginTransaction(){
  12.         try {
  13.             connectionUtil.getConnection().setAutoCommit(false);
  14.             System.out.println("事务开启");
  15.         } catch (SQLException e) {
  16.             e.printStackTrace();
  17.         }
  18.     }
  20. //    @AfterReturning("pointCut()")
  21.     public void commit(){
  22.         try {
  23.             connectionUtil.getConnection().commit();
  24.             System.out.println("事务提交");
  25.         } catch (SQLException e) {
  26.             e.printStackTrace();
  27.         }
  28.     }
  30. //    @AfterThrowing("pointCut()")
  31.     public void rollback(){
  32.         try {
  33.             connectionUtil.getConnection().rollback();
  34.             System.out.println("事务回滚");
  35.         } catch (SQLException e) {
  36.             e.printStackTrace();
  37.         }
  38.     }
  40. //    @After("pointCut()")
  41.     public void close(){
  42.         try {
  43.             connectionUtil.close();
  44.         } catch (Exception e) {
  45.             e.printStackTrace();
  46.         }
  48.     }
  51.     //环绕通知和四大通知的方式任选其一
  52.     @Around("pointCut()")//环绕通知的注解
  53.     public Object around(ProceedingJoinPoint pjp){
  54.         Object[] args = pjp.getArgs();//获取真实对象方法的参数列表
  55.         Object obj = null;
  56.         try {
  57.             //开启事务
  58.             beginTransaction();
  59.             obj = pjp.proceed(args);//类似于动态代理中的method.invoke(),是在调用真实对象的方法
  60.             //提交事务
  61.             commit();
  62.         } catch (Throwable throwable) {
  63.             throwable.printStackTrace();
  64.             //回滚事务
  65.             rollback();
  66.         } finally {
  67.             //释放资源
  68.             close();
  69.         }
  70.         return obj;
  71.     }
  72. }

声明式事务

spring提供了声明式事务的接口PlatformTransactionManager接口，使用其实现类DatasourceTransactionManager即可实现声明式事务。

声明式事务中不关心事务开启和资源释放，只关心commit和rollback。

xml实现声明式事务

使用XML实现spring声明式事务的步骤：

0.导入依赖

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework</groupId>
  4.             <artifactId>spring-context</artifactId>
  5.             <version>5.2.8.RELEASE</version>
  6.         </dependency>
  7.         <dependency>
  8.             <groupId>org.springframework</groupId>
  9.             <artifactId>spring-tx</artifactId>
  10.             <version>5.2.8.RELEASE</version>
  11.         </dependency>
  12.         <dependency>
  13.             <groupId>org.springframework</groupId>
  14.             <artifactId>spring-jdbc</artifactId>
  15.             <version>5.2.8.RELEASE</version>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>com.alibaba</groupId>
  19.             <artifactId>druid</artifactId>
  20.             <version>1.1.22</version>
  21.         </dependency>
  22.         <dependency>
  23.             <groupId>mysql</groupId>
  24.             <artifactId>mysql-connector-java</artifactId>
  25.             <version>5.1.43</version>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>org.projectlombok</groupId>
  29.             <artifactId>lombok</artifactId>
  30.             <version>1.18.18</version>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>org.aspectj</groupId>
  34.             <artifactId>aspectjweaver</artifactId>
  35.             <version>1.9.6</version>
  36.         </dependency>
  37.     </dependencies>
  1. 配置事务管理器；
  2. 配置事务通知：为业务层方法配置事务，并设置事务属性；
  3. 配置aop：配置切入点表达式，并让切入点表达式与事务通知产生关联；
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
  5.        xmlns:aop="http://www.springframework.org/schema/aop"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.        http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
  8.     <!--配置数据访问层实现类-->
  9.     <bean id="accountDao" class="com.woniuxy.dao.impl.AccountDaoImpl">
  10.         <property name="jdbcTemplate" ref="jdbcTemplate"/>
  11.     </bean>
  13.     <!--配置业务层实现类-->
  14.     <bean id="accountService" class="com.woniuxy.service.impl.AccountServiceImpl">
  15.         <property name="accountDao" ref="accountDao"/>
  16.     </bean>
  17.     <!--配置数据库连接池-->
  18.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
  19.         <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
  20.         <property name="url" value="jdbc:mysql:///bank?characterEncoding=UTF-8&amp;useSSL=false"/>
  21.         <property name="username" value="root"/>
  22.         <property name="password" value="root"/>
  23.     </bean>
  24.     <!--配置jdbcTemplate-->
  25.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  26.         <property name="dataSource" ref="dataSource"/>
  27.     </bean>
  30.     <!-- 配置事务管理器 -->
  31.     <bean id="transactionManager"
  32.           class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  33.         <property name="dataSource" ref="dataSource"/>
  34.     </bean>
  36.     <!--配置事务通知-->
  37.     <tx:advice id="txAdvice" transaction-manager="transactionManager">
  38.         <tx:attributes>
  39.     <!--
  40.         isolation：设定事务隔离级别，用于保证数据的完整性。
  41.             DEFAULT，默认使用数据库的事务隔离级别
  42.             READ_UNCOMMITTED，可读取未提交数据，有可能出现脏读、不可重复读、幻读
  43.             READ_COMMITTED，可读取已提交数据，有可能出现不可重复读、幻读
  44.             REPEATABLE_READ，读取的数据表被加行锁，有可能出现幻读
  45.             SERIALIZABLE，读取的数据表加表锁，安全程度最高
  46.         propagation：当被事务控制的业务方法进行相互调用时，设定事务的传播行为。
  47.             REQUIRED，默认，之前的操作中有事务时加入该事务，没有事务时创建一个事务（增删改）；
  48.             SUPPORTS，之前的操作中有事务时加入该事务，没有事务时不使用事务（查询）
  49.             MANDATORY，必须在事务内部执行，没有事务就报异常
  50.             REQUIRES_NEW，将原有事务挂起，新建一个事务执行自己的操作，两个事务之间没有关联
  51.             NOT_SUPPORTED，必须在非事务内部执行，如果有事务存在，将事务挂起，执行自己的操作
  52.             NEVER，不能在事务内部执行，有事务就报异常
  53.             NESTED，之前的操作有事务时，创建一个嵌套事务，两个事务之间会产生关联
  54.         read-only：设定事务是否只读。默认false，读写（增删改），true，只读（查询）
  55.         timeout：设定事务的超时时间，默认-1，永不超时，设定数值时，以秒为单位计算
  56.         no-rollback-for：
  57.             设定一个异常，事务执行过程中出现该异常时不回滚，其它异常会回滚，不设默认全回滚
  58.         rollback-for：
  59.             设定一个异常，事务执行过程中出现该异常时回滚，其它异常不会回滚，不设默认全回滚
  60.             建议手动抛异常时设定该属性
  61.     -->
  62.             <tx:method name="*" propagation="REQUIRED" read-only="false"/>
  63.             <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
  64.         </tx:attributes>
  65.     </tx:advice>
  67.     <!-- 配置aop -->
  68.     <aop:config>
  69.         <aop:pointcut id="pt" expression="execution(* com.woniuxy.service.impl.*.*(..))"/>
  70.         <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
  71.     </aop:config>
  74.     <!--
  75.         声明式事务的实现步骤：
  76.         1、导入依赖   spring-tx(必须) spring-context(核心容器+aop) spring-jdbc mysql驱动  druid
  77.         2、编写核心配置文件
  78.         2.1配置事务管理器：datasourcetransactionmanager
  79.         2.2配置事务通知：tx:advice  transaction-manager属性引用配置好的事务管理器
  80.         tx:attributes
  81.         tx:method name="*" propagation="REQUIRED" read-only="false"   给增删改的业务层方法使用
  82.         tx:method name="find*" propagation="SUPPORTS" read-only="true"   给业务层的查询方法使用
  83.         2.3配置aop:
  84.         配置切入点
  85.         配置tx:advisor  引用事务通知   引用切入点
  86.     -->
  88. </beans>

常用注解

注解名 作用
@Configuration 用在配置类上
@Component 无语义的类上
@Service 用在业务层实现类上
@Repository 用在数据访问层实现类上
@Controller 用在控制层的类上
@Value 用于给类的属性赋值
@Autowired 根据类型自动注入，用于进行自动注入的成员变量上
@Resource 先byName，再byType。用于进行自动注入的成员变量上
@Primary 用于在要优先注入的类上
@Qualifier 用于在成员变量上，用于指定注入一个容器中的bean
@Bean 用于将第三方的类注册到spring容器中，用在某个方法上，将方法返回值注册到容器
@ComponentScan 用在配置类上，用于指定扫描的包
@PropertySource 用于在配置类上，用于加载类路径下的properties文件
@Scope 用在类上，用于指定当前类的作用范围，一般用于配置多例或单例
@Aspect 用在切面类上，
@PointCut 用在方法上，用于配置切入点表达式
@Before@After@AfterReturning@AfterThrowing@Around 用在切面类的方法上，五大通知
@EnableAspectJAutoProxy 用在配置类上，用于开启aspectj的自动代理（识别aspectj的注解）
@EnableTransactionManagement 用在配置类上，用于开启注解事务
@Transactional 用在业务层实现类上或实现类的方法上，用于指定事务策略
@Import 用在配置类上，用于导入另外一个配置类

注解实现声明式事务

1、编写配置类

  1. @Configuration
  2. @EnableTransactionManagement//开启注解事务管理
  3. @ComponentScan(basePackages = {"com.woniuxy"})
  4. public class AppConfig {
  6.     @Bean("dataSource")
  7.     public DataSource dataSource(){
  8.         DruidDataSource dataSource = new DruidDataSource();
  9.         dataSource.setDriverClassName("com.mysql.jdbc.Driver");
  10.         dataSource.setUrl("jdbc:mysql:///bank?characterEncoding=UTF-8&useSSL=false");
  11.         dataSource.setUsername("root");
  12.         dataSource.setPassword("root");
  13.         return dataSource;
  14.     }
  16.     @Bean
  17.     public JdbcTemplate jdbcTemplate(DataSource dataSource){
  18.         JdbcTemplate jdbcTemplate = new JdbcTemplate();
  19.         jdbcTemplate.setDataSource(dataSource);
  20.         return jdbcTemplate;
  21.     }
  23.     @Bean
  24.     public DataSourceTransactionManager dataSourceTransactionManager(){
  25.         DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
  26.         dataSourceTransactionManager.setDataSource(dataSource());
  27.         return dataSourceTransactionManager;
  28.     }
  30. }

2、使用@Transactional注解进行事务控制

@Transactional注解用在类上，表示类中所有方法使用同一种事务策略

也可以将其放在方法上，表示当前被注解的方法使用特定的事务策略。

  1. @Service("accountService")
  2. @Transactional
  3. public class AccountServiceImpl implements AccountService {
  5.     @Resource
  6.     private AccountDao accountDao;
  8.     @Transactional(propagation = Propagation.SUPPORTS,readOnly = true)
  9.     public Account findByUserName(String username){
  10.         return null;
  11.     }
  14.     @Override
  15.     public void transfer(String source, String target, Double money) throws SQLException {
  16.         //查询要进行转帐操作的两个人的帐户信息
  17.         Account sourceAccount = accountDao.findByUsername(source);
  18.         Account targetAccount = accountDao.findByUsername(target);
  20.         //判断被转出人的帐户余额是否足够
  21.         if (sourceAccount.getBalance()>money) {
  22.             //真正执行转账操作
  24.             sourceAccount.setBalance(sourceAccount.getBalance()-money);
  25.             targetAccount.setBalance(targetAccount.getBalance()+money);
  27.             accountDao.updateAccount(sourceAccount);
  28. //            System.out.println(1/0);
  29.             accountDao.updateAccount(targetAccount);
  31.         }else{
  32.             throw new RuntimeException("余额不足");
  33.         }
  34.     }
  35. }

spring整合mybatis

  1.     对于spring项目中整合mybatsi前置条件：导入spring本身的依赖，以及mybatis的依赖，还需要多导入一个整合mybatis与spring的依赖（mybatis提供的）。

1、导入依赖：spring-context spring-jdbc mybatis-spring mybatis mysql-connector-java druid lombok

2、编写spring的配置文件

a)扫描包下的注解（spring本身的注解）

b)配置数据库连接池（druid）

c)SqlSessionFactoryBean(注入一个datasource)

d)MapperScannerConfigurer 指定扫描的包（basepackage:扫描创建mapper接口的代理对象）

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  7.         <!--扫包-->
  8.     <context:component-scan base-package="com.woniuxy"/>
  9.         <!--配置数据库连接池-->
  10.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
  11.         <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
  12.         <property name="url" value="jdbc:mysql:///bank?characterEncoding=utf-8&amp;useSSL=false"/>
  13.         <property name="username" value="root"/>
  14.         <property name="password" value="root"/>
  15.     </bean>
  17.     <!--
  18.         配置sqlSessionFactoryBean
  19.         作用：产生一个sqlsessionfactory 只要ioc容器中有任何一个bean需要使用sqlsession，
  20.         那么就会由sqlsessionfactory自动创建一个给其使用。
  21.      -->
  22.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  23.         <property name="dataSource" ref="dataSource"/>
  24. <!--        <property name="configLocation" value="classpath:sqlConfig.xml"/>-->
  25.     </bean>
  27.     <!--
  28.         配置MapperScannerConfigurer:
  29.         作用：用于扫描指定的包，创建对应接口的代理对象
  30.      -->
  31.     <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  32.         <property name="basePackage" value="com.woniuxy.mapper"/>
  33.     </bean>
  34. </beans>

ajax传递参数.png