Spring知识点，这篇搞定（二）

public class  MyBeanPoster implements BeanPostProcessor  {
 
  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName)
      throws BeansException {
    return bean;
  }
 
  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    // 要进行类型判断，如果不是Student类型的话直接返回，不然会报类型转换错误，因为Spring会把工厂中的所有对象进行加工处理
    if (bean instanceof Student){
      Student student = (Student) bean;
      student.setName("lisi");
    }
    return bean;
  }
}
 

  <bean id="student" class="com.beanpost.Student">
    <property name="id" value="10"/>
    <property name="name" value="zs"/>
  </bean>
<!--注册后置Bean-->
  <bean id="myBeanProcessor" class="com.beanpost.MyBeanPoster"/>
 

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
  private String username;
  private String password;
}

public interface UserService {
   void register(User user);
 
   void login(String username,String password);
}

public class UserServiceImpl implements UserService {
 
  @Override
  public void register(User user) {
    System.out.println("注册了");
  }
 
  @Override
  public void login(String username, String password) {
    System.out.println("登录了");
  }
}

public class UserServiceProxy implements UserService {
 
  // 原始类对象
  UserServiceImpl userService = new UserServiceImpl();
  @Override
  public void register(User user) {
    System.out.println("增加了日志的额外功能");
    userService.register(user);
  }
 
  @Override
  public void login(String username, String password) {
    System.out.println("增加了登录日志的额外功能");
    userService.login(username,password);
  }
}
 

public class UserServiceImpl implements UserService {
 
  @Override
  public void register(User user) {
    System.out.println("注册了");
  }
 
  @Override
  public void login(String username, String password) {
    System.out.println("登录了");
  }
}
 

 <bean id="UserServiceImpl" class="com.proxy.dynamicProxy.UserServiceImpl"/>

public class Before implements MethodBeforeAdvice {
 
  // 额外功能书写在接口的实现中，运行在原始方法执行之前运行额外功能
  @Override
  public void before(Method method, Object[] objects, Object o) throws Throwable {
    System.out.println("---method before advice log---");
  }
}
 

  <aop:config>
<!--    切入点，id属性是唯一标识符，expression属性是切入点表达式，这个切入点表达式的意思是所有方法都作为切入点都加入额外功能-->
    <aop:pointcut id="testaop" expression="execution(* *(..))"/>
  </aop:config>

public class Arround implements MethodInterceptor {
 
  /*
  书写额外功能的方法
  参数：MethodInvocation表示的是额外功能所增加给的那个原始方法。
  运行原始方法：methodInvocation.proceed(),在原始方法前面写的代码就运行在原始方法之前，反之。
  返回值：代表原始方法返回值
   */
  @Override
  public Object invoke(MethodInvocation methodInvocation) throws Throwable {
    System.out.println("前置增强");
    Object proceed = methodInvocation.proceed();
    System.out.println("后置增强");
    return proceed;
  }
}

* login(String,String)

# 切入点包中的所有类，必须在proxy中，不能在proxy包的子包中
* com.domain.proxy.*.*(..)
 
# 如果想要当前包及其当前包的子包都进行功能增强的话，必须要这样写
* com.domain.proxy..*.*(..)

# 切入点想选为某个类(UserServiceImpl这个类作为切入点)
whithin(*..UserServiceImpl)
# 切入点想选为某个包
within(com.poroxy..*)

// 先写一个自定义注解
@Target(ElementType.METHOD) // 表示可以加在哪里
@Retention(RetentionPolicy.RUNTIME) // 表示什么时候起作用
public @interface Log {
}

    <aop:pointcut id="testaop" expression="@annotation(com.anno.Log)"/>

  @Log
  @Override
  public void register(User user) {
    System.out.println("注册了");
  }

# 案例一：满足方法名为login且参数为两个字符串
execution (* login(..) and args(String,String))

# 案例一：满足方法名为login或register作为切入点
execution(* login(..)) or execution(* register(..))

public class TestJDKProxy {
 
  public static void main(String[] args) {
    // 1. 创建原始对象
    UserService userService = new UserServiceImpl();
 
    // 2. 创建JDK动态代理
    InvocationHandler handler = new InvocationHandler() {
       
      @Override
                     // 参数一：表示代理对象   参数二：额外功能所增加给的原始方法  参数三： 表示原始方法的参数
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       
        // 原始对象的方法方法运行
        Object ret = method.invoke(userService,args);
        System.out.println("========after proxy log========");
        return ret;
      }
    };
    UserService userServiceProxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(),userService.getClass().getInterfaces(),handler);
    userServiceProxy.login("admin","123456");
    userServiceProxy.register(null);
  }
}

package cn.linstudy.cglibProxy.service;
 
import cn.linstudy.cglibProxy.domain.User;
 
/**
 * @Description
 * @Author XiaoLin
 * @Date 2021/2/25 18:44
 */
public interface UserServiceImpl {
 
  void login(String username,String password);
 
  void register(User user);
}
 

package cn.linstudy.cglibProxy.proxy;
 
import cn.linstudy.cglibProxy.domain.User;
import cn.linstudy.jdkProxy.service.impl.UserServiceImpl;
 
/**
 * @Description
 * @Author XiaoLin
 * @Date 2021/2/25 18:45
 */
public class UserServiceProxy extends UserServiceImpl {
 
  @Override
  public void login(String username, String password) {
    System.out.println("登录了"+username+password);
  }
 
  @Override
  public void register(User user) {
    System.out.println("注册了"+user);
  }
}

public class TestCGlib {
 
  public static void main(String[] args) {
    // 创建原始对象
    UserService userService = new UserService();
 
    // 通过CGlib方式创建代理对象
    Enhancer enhancer = new Enhancer();
    enhancer.setClassLoader(userService.getClass().getClassLoader()); // 设置类加载器
    enhancer.setSuperclass(userService.getClass()); // 设置父类
    MethodInterceptor interceptor = new MethodInterceptor() {
      // 等同于InvocationHandler 的 invoke 方法
      @Override
      public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy)
          throws Throwable {
        System.out.println("=====cglib log=====");
        Object ret = method.invoke(userService, args);
        return  ret;
      }
    };
    enhancer.setCallback(interceptor);
    UserService serviceProxy = (UserService) enhancer.create();
    serviceProxy.login();
    serviceProxy.register();
  }
}
 

public class UserServiceImpl implements UserService {
  
  @Override
  public void register(User user) {
    System.out.println("注册了");
  }
 
  @Override
  public void login(String username, String password) {
    System.out.println("登录了");
  }
}

@Aspect
public class MyAspect {
 
  @Around("execution(* * (..))") // 写切入点表达式
    // joinPoint 表示原始方法
  public Object Around(ProceedingJoinPoint joinPoint) throws Throwable { 
    System.out.println("====aspect前置增强====");
    Object ret = joinPoint.proceed(); // 代表原始方法执行
    System.out.println("====aspect后置增强====");
    return ret;
  }
}

@Aspect
public class MyAspect {
 
  // 将公共的切入点表达式提取出来，注意的是，注解所在的方法必须是public void修饰，且没有方法体
  @Pointcut("execution(* * (..))")  
@Around(value = "MyPoint()") // 引入切入点表达式
  public Object Around(ProceedingJoinPoint joinPoint) throws Throwable { // joinPoint 表示原始方法
    System.out.println("====aspect前置增强====");
    Object ret = joinPoint.proceed(); // 代表原始方法执行
    System.out.println("====aspect后置增强====");
    return ret;
  }
 
 
  @Around(value = "MyPoint()") // 引入切入点表达式
  public Object Around1(ProceedingJoinPoint joinPoint) throws Throwable { // joinPoint 表示原始方法
    System.out.println("====aspect tx====");
    Object ret = joinPoint.proceed(); // 代表原始方法执行
    System.out.println("====aspect tx====");
    return ret;
  }
}

package cn.lin;
 
import org.springframework.stereotype.Component;
 
@Component
@Data
public class User {
  private String id;
  private String username;
  private String password;
}
 

<?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"
  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">
 
  <context:component-scan base-package="cn.lin"/>
</beans>

package cn.lin;
 
import static org.junit.Assert.*;
 
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
/**
 * @Description
 * @Author XiaoLin
 * @Date 2021/2/24 21:58
 */
public class UserTest {
  /**
  * 用于测试注解@Component
  */
  @Test
  public void testComponent(){
    ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
    User user = app.getBean("user", User.class);
    System.out.println(user);
  }
}

// 单例模式，只会创建一次
@Scope("singleton")
public class User(){
    
}

@Component
@Data
public class User {
 
  // 表示这个是一个初始化方法
  @PostConstruct
  public void MyInit(){
    System.out.printf("User Init");
  }
 

package cn.lin.dao;
 
import cn.lin.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;
 
/**
 * @Description
 * @Author XiaoLin
 * @Date 2021/2/26 9:18
 */
 
@Repository
public class UserMapperImpl implements UserMapper{
 
  @Override
  public void login(User user) {
    System.out.printf("登录了");
  }
}
 

package cn.lin.service;
 
import cn.lin.User;
 
/**
 * @Description
 * @Author XiaoLin
 * @Date 2021/2/26 9:19
 */
 
public interface UserService {
  void login(User user);
}
 

package cn.lin.service.impl;
 
/**
 * @Description
 * @Author XiaoLin
 * @Date 2021/2/26 9:19
 */
@Service
public class UserServiceImpl implements UserService {
 
  @Autowired
  private UserMapper userMapper;
 
 
  @Override
  public void login(User user) {
    userMapper.login(new User());
  }
}

 /**
  * 用于测试
  */
  @Test
  public void test(){
    ApplicationContext app = new ClassPathXmlApplicationContext("/applicationContext.xml");
    UserService userService = (UserService)app.getBean("userServiceImpl");
    userService.login(new User());
  }

 /**
  * 用于测试Spring与Mybatis整合
  */
  @Test
  public void testSpringMybatis(){
    ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext(
        "/applicationContext.xml");
    UserMapper userMapper = (UserMapper) app.getBean("userMapper");
    List<User> users = userMapper.queryAll();
    System.out.println(users);
 
  }

分析：本质上谁控制了链接对象，谁就可以提交事物。连接对象是由连接池来获取的：
1. MyBatis提供的连接池对象：他将Connection.setAutoCommit的值从默认值true设置成为了false，所以导致无法自动提交，手动控制事物，需要在操作完成后，手工提交事务。
2. Druid（C3P0、DBCP）提供的连接池对象：Connection.setAutoCommit的值为默认值true，保持自动控制事物，自动提交。

@Transactional // 切入点，给谁加入事物
public class UserServiceImpl implements UserService {
 
  private UserMapper userMapper;
 
  public UserMapper getUserMapper() {
    return userMapper;
  }
 
  public void setUserMapper(UserMapper userMapper) {
    this.userMapper = userMapper;
  }
  @Override
  public List<User> queryAll() {
    return userMapper.queryAll();
  }
}

# 我们可以用命令来查询MySQL的默认属性。
select @@tx_isolation

// 异常属性有两个值
// 1. rollbackFor();表示回滚的异常类型，里面写异常的类型的字节码对象,他里面的值的类型是数组类型，所以可以写多个异常类型的字节码对象，用逗号隔开
rollbackFor({java.lang.Exception.class});
 
// noRollbackFor();表示不会滚的异常类型的字节码对象
noRollbackFor({java.lang.RuntimeException.class})

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>
 
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.6</version>
    </dependency>
 
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.1.5.RELEASE</version>
    </dependency>
 
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.1.5.RELEASE</version>
    </dependency>
 
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>5.1.5.RELEASE</version>
    </dependency>
 
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.1.5.RELEASE</version>
    </dependency>
 
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.1.5.RELEASE</version>
    </dependency>
 
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.2</version>
    </dependency>
 
    <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.13</version>
    </dependency>
 
 
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>
 
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.12</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.8.8</version>
    </dependency>
 
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.3</version>
    </dependency>
 
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.25</version>
    </dependency>
 
    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
 
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
 
    <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
 
    <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.3.1</version>
      <scope>provided</scope>
    </dependency>
 
  </dependencies>

1. Web开发过程中如何创建工厂
ApplicationContext ctx = new WebXmlApplication("/applicationContext.xml");
 
2. 如何保证工厂被共用同时保证唯一性
被共用：在Web中有四个作用于：request、session、ServletContext（application）,我们可以把工厂存储到ServletContext这个作用域中。
唯一性：我们可以利用ServletContextListener这个监听器，因为在ServletContext对象创建的同时，ServletContextListener会被调用且只被调用一次。所以我们可以把工厂创建的代码写在ServletContextListener中，这样就保证了唯一性。
 
3. 总结
我们首先在ServletContextListener这个监听器中书写创建工厂的代码，其次将这个工厂放在ServletContext对象中。
 
4. Spring的封装
既然这些代码如此繁琐，那么Spring肯定会帮我们封装好了。
 
5. ContextLoaderListener类
Spring封装了一个ContextLoaderListener类，他的作用是创建工厂和将工厂放进ServletContext对象中。
 
 
 

<!---我们只需要在web.xml中进行配置即可-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
        <!--告诉Spring我们的配置文件在哪里-->
<context-param>
<param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
</context-param>