Spring学记笔记_03

8.AOP

8.1AOP在Spring中的作用

• 横切关注点就是我们需要扩展的某个功能！！

• 切面就是我们自定义的拓展的功能类！！

• 通知就是自定义类中的方法！！

• 目标就是相应的原始抽象角色！！（接口对象）

• 代理

• 切入点—pointcut，自定义类所要添加的地点！！

8.2使用Spring实现AOP

方法一：使用Spring的API接口

• 接口UserService

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

• 接口实现类

public class UserServiceImpl implements UserService{

    public void add() {
        System.out.println("添加了一个用户！");
    }

    public void delete() {
        System.out.println("删除了一个用户！");
    }

    public void update() {
        System.out.println("修改了一个用户！");
    }

    public void query() {
        System.out.println("查询了一个用户！");
    }
}

• 新的需求类Log

import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {
    //method:要执行的目标对象的方法
    //args:参数
    //target:目标对象（抽象角色/接口对象）
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了！");
    }
}

• 新的需求类AfterLog

import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;

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);
    }
}

• 配置文件xml

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService" class="com.eicoma.service.UserServiceImpl"/>
    <bean id="log" class="com.eicoma.log.Log"/>
    <bean id="afterLog" class="com.eicoma.log.AfterLog"/>

    <!--方式一：使用原生的Spring API接口-->
    <!--配置AOP：需要导入AOP的约束-->
    <aop:config>
        <!--切入点：expression:表达式，execution:该扩展功能类需要添加的位置！-->
        <aop:pointcut id="pointcut1" expression="execution(* com.eicoma.service.UserServiceImpl.*(..))"/>

        <!--执行环绕增加（说白了就是给原有的输出前后加上log和afterLog）-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut1"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut1"/>
    </aop:config>

</beans>

• 测试类

import com.eicoma.service.UserService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //底层使用的动态代理，需要接口对象，此处getBean获取到的是Object对象，需强转
        UserService userService = (UserService) context.getBean("userService");

        userService.add();
        userService.delete();
    }
}

方法二：使用自定义类实现AOP

• 自定义功能类

//这个类就是切面
public class DiyPointCut {
    //方法就是通知
    public void before(){
        System.out.println("*******方法执行前*******");
    }

    public void after(){
        System.out.println("*******方法执行后*******");
    }
}

• xml配置

    <!--方式二：自定义类-->
    <bean id="diy" class="com.eicoma.diy.DiyPointCut"/>

    <aop:config>
        <!--自定义切面，ref ：要引用的类-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* com.eicoma.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

方法三：通过注解实现AOP

• 扩展方法的类及注解

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AnnotationPointCut {

    @Before("execution(* com.eicoma.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("========方法执行前========");
    }

    @After("execution(* com.eicoma.service.UserServiceImpl.*(..)))")
    public void after(){
        System.out.println("========方法执行后========");
    }

    @Around("execution(* com.eicoma.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable{
        System.out.println("环绕前");
        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }
}

• xml中的配置

    <!--方式三-->
    <bean id="annotationPointCut" class="com.eicoma.diy.AnnotationPointCut"/>
    <!--开启注解支持-->
    <aop:aspectj-autoproxy/>

9.整合Mybatis

步骤：

1. 导入相关jar包

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--Spring要操作数据库，还需要一个spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <!--AOP织入包-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

2. 编写配置文件
3. 测试

9.1mybatis流程

1. 编写实体类
2. 编写核心配置文件
3. 编写接口
4. 编写Mapper.xml
5. 测试

9.2MyBatis-Spring

• 整合Mybatis和Spring的步骤

1. 在Spring配置文件中编写数据源配置

   <!--DataSource:使用Spring的数据源替换Mybatis的配置-->
   <!--这里使用了Spring提供的JDBC：org.springframework.jdbc.datasource-->
   <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
       <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
       <property name="url" value="jdbc:mysql://localhost:3306/db2?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
       <property name="username" value="root"/>
       <property name="password" value="root1999"/>
   </bean>
   

2. 注册SqlSessionFactory

   <!--sqlSessionFactory-->
   <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
       <property name="dataSource" ref="dataSource" />
       <property name="configLocation" value="classpath:mybatis-config.xml"/>
       <property name="mapperLocations" value="classpath:com/eicoma/mapper/*.xml"/>
   </bean>
   

3. 注册SqlSessionTemplate

   <!--SqlSessionTemplate   为了得到SqlSession对象-->
   <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
       <!--SqlSessionTemplate没有set方法，只能用构造器注入-->
       <constructor-arg index="0" ref="sqlSessionFactory"/>
   </bean>
   

4. 编写接口实现类

   import com.eicoma.pojo.User;
   import org.mybatis.spring.SqlSessionTemplate;
   
   import java.util.List;
   
   public class UserMapperImpl implements UserMapper{
       private SqlSessionTemplate sqlSession;
   
       public void setSqlSession(SqlSessionTemplate sqlSession) {
           this.sqlSession = sqlSession;
       }
   
       public List<User> selectUser() {
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
           List<User> users = mapper.selectUser();
           return users;
       }
   }
   

5. 将接口实现类注册到Spring

   <!--UserMapper接口实现类对象-->
   <bean id="userMapper" class="com.eicoma.mapper.UserMapperImpl">
       <property name="sqlSession"  ref="sqlSession"/>
   </bean>
   

6. 测试

   public class MyTest {
   
       @Test
       public void test() throws IOException {
           ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
           UserMapper userMapper =(UserMapper) context.getBean("userMapper");
   
           for (User user : userMapper.selectUser()){
               System.out.println(user);
           }
       }
   }
   

10.声明式事务

10.1回顾事务

• 把一组业务当成一个业务来做，要么都成功，要么都失败
• 事务在项目开发中，涉及到数据的一致性问题！非常重要！
• 确保完整性和一致性

事务ACID原则

• 原子性
• 一致性
• 隔离性
  • 多个业务可能操作同一个资源，防止数据损坏
• 持久性
  • 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化地写到存储器中

10.2 Spring中的事务管理

• 声明式事务：AOP（切面式编程，不影响原有代码）
• 编程式事务：在代码中，进行事务的管理

为什么需要事务？

• 若不配置事务，可能导致数据提交不一致的情况出现！
• 如果不在Spring中进行声明式事务配置，就需要在代码中手动配置事务！
• 事务关系到数据的完整性和一致性！！