四十一、Spring 学习三

1、AOP

1.1、什么是AOP

AOP（Aspect Oriented Programming），意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

1.2 AOP在Spring中的作用

提供声明式事务；允许用户自定义切面

• 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
• 切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
• 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
• 目标（Target）：被通知对象。
• 代理（Proxy）：向目标对象应用通知之后创建的对象。
• 切入点（PointCut）：切面通知执行的“地点”的定义。
• 连接点（JointPoint）：与切入点匹配的执行点。

即 Aop在 不改变原有代码的情况下，去添加新的功能

1.3、使用Spring实现Aop

【重点】使用AOP织入，需要导入一个依赖包

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

准备工作

1. 接口和实现接口的实现类

   public interface UserService {
   public void add();
   public void delete();
   public void update();
   public void select();
   }

1. 方式一：使用Spring的API接口【主要SpringAPI接口实现】

   1. Log ```java public class Log implements MethodBeforeAdvice {

   // method: 要执行的目标对象的方法 // args: 参数 // target: 目标对象

   public void before(Method method, Object[] args, Object target) throws Throwable {

   System.out.println(target.getClass()+"的"+method.getName()+"执行了");

   } } ```

1. AfterLog

   public class AfterLog implements AfterReturningAdvice {
   // returnValue : 返回值
   public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
    System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
   }
   }

1. 编写AOP ```xml

<aop:config>
    <!--切入点：expression:表达式，execution(* com.shuai.service.UserServiceImpl.*(..))-->
    <aop:pointcut id="pointcut" expression="execution(* com.shuai.service.UserServiceImpl.*(..))"/>
    <!--执行环绕添加-->
    <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>

3.  方式二：自定义来实现AOP【主要是切面定义】 
   1.  编写一个类 
```java
public class DiyPointCut {
    public void before(){
        System.out.println("========方法执行前==========");
    }
    public void after(){
        System.out.println("========方法执行后==========");
    }
}

1. 编写AOP ```xml

<bean id="diy" class="com.shuai.diy.DiyPointCut"/>
<aop:config>
    <aop:aspect ref="diy">
        <aop:pointcut id="point" expression="execution(* com.shuai.service.UserServiceImpl.*(..))"/>
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

4.  方式三：使用注解实现！ 
   1.  编写一个类 
```java
// 方式三：使用注解方式实现AOP
@Aspect   // 标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.shuai.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("======方法执行前=======");
    }
    @After("execution(* com.shuai.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("========方法执行后========");
    }
    @Around("execution(* com.shuai.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        Signature signature = jp.getSignature(); // 获得签名
        System.out.println("signature:"+ signature);
        Object proceed = jp.proceed();   // 执行方法
        System.out.println("环绕后");
        System.out.println(proceed);
    }
}

1. 编写AOP ```xml

<!--sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!--绑定Mybatis配置文件-->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <property name="mapperLocations" value="classpath:com/shuai/dao/UserMapper.xml"/>
</bean>
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
<bean id="userMapper" class="com.shuai.dao.UserMapperImpl">
    <property name="sqlSession" ref="sqlSession"/>
</bean>

6.  编写实体类 
   1.  方式一(UserMapperImpl) 
```java
public class UserMapperImpl implements UserMapper{
    // 我们的所有操作，都是用sqlSession来执行，在原来，现在都是用SqlSessionTemplate;
    private SqlSessionTemplate sqlSession;
    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }
    public List<User> selectUser() {
        return sqlSession.getMapper(UserMapper.class).selectUser();
    }
}

3.  编写实体类（UserMapperImpl） 
```java
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper{
    public List<User> selectUser() {
        User user = new User(5, "少帅", "123456");
        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
        mapper.addUser(user);
        mapper.deleteUser(3);
        return mapper.selectUser();
    }
    public int addUser(User user) {
        return getSqlSession().getMapper(UserMapper.class).addUser(user);
    }
    public int deleteUser(int id) {
        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
    }
}