Spring（二）

Spring的Bean管理（注解方式）

导入包

在Spring的注解AOP中需要导入spring-aop的jar包

image.png

引入约束

image.png

快速入门

编写一个UserDao的接口

package com.cuzz;

public interface UserDao {
    public void sayHello();
}

编写一个UserDao接口的实现类

package com.cuzz;

public class UserDaoImpl implements UserDao {
    @Override
    public void sayHello() {
        System.out.println("Hello Spring...");
    }
}

在applicationContext.xml配置
Spring的注解开发：组件扫描

在类中添加注解

package com.cuzz;

import org.springframework.stereotype.Component;

@Component(value="userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void sayHello() {
        System.out.println("Hello Spring Annotation...");
    }
}

测试

package com.cuzz;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class TestDemo {
    @Test
    public void fun1() {
        // 创建spring工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过工厂解析xml获取Bean的实例
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        userDao.sayHello();   // 输出 Hello Spring Annotation...
    }
}

Bean管理的常用注解

类注解

Spring 中提供@Component 的三个衍生注解:(功能目前来讲是一致的)

@Controller ：WEB 层
@Service ：业务层
@Repository ：持久层
这三个注解是为了让标注类本身的用途清晰

Spring 属性注入的注解

@Value ：用于注入普通类型.
@Autowired ：自动装配，默认按类型进行装配.
@Qualifier：强制使用名称注入.
@Resource ：相当于@Autowired 和@Qualifier 一起使用

Bean 的作用范围的注解

@Scope(singleton)：单例
@Scope(prototype)：多例

Bean的生命周期的配置

@PostConstruct ：相当于 init-method
@PreDestroy ：相当于 destroy-method

代码演示

配置扫描路径

编写一个Car类

package com.cuzz.pojo;

import org.springframework.stereotype.Component;

@Component("car")
public class Car {
    
    private String name;
    private Integer price;
    
    public Car() {
        super();
    }
    
    public Car(String name, Integer price) {
        super();
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car [name=" + name + ", price=" + price + "]";
    }
}

编写一个User类

package com.cuzz.pojo;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component("user")
// @Service("user") service层
// @Controller("user") web层
// @Repository("user") dao层
public class User {
    private String name;

    @Value("18")
    private Integer age;

    // 自动装配
    // @Autowired
    @Resource(name="car")
    private Car car;
    
    public User() {
        super();
    }
    
    public User(String name, Integer age, Car car) {
        super();
        this.name = name;
        this.age = age;
        this.car = car;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + ", car=" + car + "]";
    }
}

测试

package com.cuzz.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.cuzz.pojo.User;

public class TestDemo {
    @Test
    public void fun1() {
        // 创建spring工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过工厂解析xml获取Bean的实例
        User user = (User) applicationContext.getBean("user");
        System.out.println(user);
    }
}

注解测试
导入spring-test包spring-test-4.2.4.RELEASE.jar

package com.cuzz.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.cuzz.pojo.User;

@RunWith(SpringJUnit4ClassRunner.class)
// 指定创建容器时使用的配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class TestDemo2 {
    
    // 将名为user的对象注入到变量u变量中
    @Resource(name="user")
    private User u;
    
    @Test
    public void fun() {
        System.out.println("sss");
    }
}

AOP面向切面编程

AOP概述

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用

底层实现

Spring 的 AOP 的底层用到两种代理机制：

JDK 的动态代理：类必须实现接口，所以是针对实现了接口的类产生代理.
Cglib 的动态代理：针对没有实现接口的类产生代理，应用的是底层的字节码增强的技术生成当前类的子类对象

JDK 的动态代理

UserService接口
实现增删改查的功能

package com.cuzz.service;

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

UserService接口的实现的类

public class UserServiceImpl implements UserService {

    @Override
    public void add() {
        System.out.println("添加一个user");
    }

    @Override
    public void delete() {
        System.out.println("删除一个user");
    }

    @Override
    public void update() {
        System.out.println("更新一个user");
    }

    @Override
    public void get() {
        System.out.println("查询一个user");
    }
}

实现动态代理

package com.cuzz.service;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class UserServiceProxyFactory implements InvocationHandler{
    
    private UserService us;

    public UserServiceProxyFactory(UserService us) {
        super();
        this.us = us;
    }
    
    // 获得动态代理
    public UserService getUserServiceProxy() {
        // 生成动态代理
        UserService usProxy = (UserService) Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader(),
                UserServiceImpl.class.getInterfaces(), 
                this);
        return usProxy;
    }
    
    @Override
    public Object invoke(Object arg0, Method method, Object[] arg2)
            throws Throwable {
        System.out.println("打开事务!");
        Object invoke = method.invoke(us, arg2);
        System.out.println("提交事务!");
        return invoke;
    }
}

测试

package com.cuzz.service;

import org.junit.Test;

public class TestDemo {
    
    @Test
    //动态代理
    public void fun1(){
        UserService us = new UserServiceImpl();
        
        UserServiceProxyFactory factory = new UserServiceProxyFactory(us);
        
        UserService usProxy = factory.getUserServiceProxy();
        
        usProxy.add();   // 打开事务!
                         // 添加一个user
                         // 提交事务!
    }
}

Cglib 的动态代理

Cglib 的动态代理的代码实现

package com.cuzz.service;

import java.lang.reflect.Method;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class UserServiceProxyFactory2 implements MethodInterceptor {
    
    public UserService getUserServiceProxy(){
        // 帮我们生成代理对象
        Enhancer en = new Enhancer();
        // 设置对谁进行代理
        en.setSuperclass(UserServiceImpl.class);
        // 代理要做什么
        en.setCallback(this);
        // 创建代理对象
        UserService us = (UserService) en.create();
        return us;
    }

    @Override
    public Object intercept(Object prxoyobj, Method method, Object[] arg, MethodProxy methodProxy) throws Throwable {
        // 打开事务
        System.out.println("打开事务!");
        // 调用原有方法
        Object returnValue = methodProxy.invokeSuper(prxoyobj, arg);
        // 提交事务
        System.out.println("提交事务!");
        
        return returnValue;
    }
}

测试

    @Test
    public void fun2(){
        
        UserServiceProxyFactory2 factory = new UserServiceProxyFactory2();
        
        UserService usProxy = factory.getUserServiceProxy();
        
        usProxy.add();
    }

Spring的AOP开发(基于AspectJ)

AOP的开发中的相关术语

Joinpoint(连接点)：所谓连接点是指那些被拦截到的点，在 spring 中这些点指的是方法，因为 spring 只支持方法类型的连接点
Pointcut(切入点)：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
Advice(通知/增强)：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Introduction(引介)：引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field
Target(目标对象)：代理的目标对象
Weaving(织入)：是指把增强应用到目标对象来创建新的代理对象的过程，spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装在期织入
Proxy（代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
Aspect(切面)：是切入点和通知（引介）的结合

导入包

spring 的传统 AOP 的开发的包
spring-aop-4.2.4.RELEASE.jar
com.springsource.org.aopalliance-1.0.0.jar
aspectJ 的开发包
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
spring-aspects-4.2.4.RELEASE.jar

引入AOP约束

image.png

目标类的配置

测试

由于我的spring-test.jar版本有点冲突，所以用不了Junit单元测试，就用原始的测试

package com.cuzz.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.cuzz.pojo.User;
import com.cuzz.service.UserService;

public class TestDemo3 {
    @Test
    public void fun1() {
        // 创建spring工厂
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 通过工厂解析xml获取Bean的实例
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.add();
        userService.delete();
        userService.update();
        userService.get();
    }
}

通知类型

前置通知：在目标方法执行之前执行
后置通知：在目标方法执行之后执行
环绕通知：在目标方法执行前和执行后执行
异常抛出通知：在目标方法执行出现异常的时候执行
最终通知：无论目标方法是否出现异常最终通知都会执行

切面类

package com.cuzz.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyAdvice {
    
    // 前置通知
    public void before(){
        System.out.println("这是前置通知!!");
    }

    // 后置通知
    public void afterReturning(){
        System.out.println("这是后置通知(如果出现异常不会调用)!!");
    }
    // 环绕通知
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("这是环绕通知之前的部分!!");
        // 调用目标方法
        Object proceed = pjp.proceed();
        System.out.println("这是环绕通知之后的部分!!");
        return proceed;
    }
    // 异常通知
    public void afterException(){
        System.out.println("出事啦!出现异常了!!");
    }
    // 后置通知
    public void after(){
        System.out.println("这是后置通知(出现异常也会调用)!!");
    }
}

配置

AOP的注解配置

导包

与前面一样

引入约束

与前面一样

配置

编写注解类

package com.cuzz.aop;

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

@Aspect
// 表示该类是一个通知类
public class MyAdvice {
    
    // 前置通知
    @Before("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public void before(){
        System.out.println("这是前置通知!!");
    }

    // 后置通知
    @AfterReturning("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public void afterReturning(){
        System.out.println("这是后置通知(如果出现异常不会调用)!!");
    }
    // 环绕通知
    @Around("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("这是环绕通知之前的部分!!");
        // 调用目标方法
        Object proceed = pjp.proceed();
        System.out.println("这是环绕通知之后的部分!!");
        return proceed;
    }
    // 异常通知
    @AfterThrowing("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public void afterException(){
        System.out.println("出事啦!出现异常了!!");
    }
    // 后置通知
    @After("execution(* com.cuzz.service..*ServiceImpl.*(..))")
    public void after(){
        System.out.println("这是后置通知(出现异常也会调用)!!");
    }
}

Spring（二）

Spring的Bean管理（注解方式）

导入包

引入约束

快速入门

Bean管理的常用注解

类注解

Spring 属性注入的注解

Bean 的作用范围的注解

Bean的生命周期的配置

代码演示

AOP面向切面编程

AOP概述

底层实现

JDK 的动态代理

Cglib 的动态代理

Spring的AOP开发(基于AspectJ)

AOP的开发中的相关术语

导入包

引入AOP约束

目标类的配置

测试

通知类型

切面类

配置

AOP的注解配置

导包

引入约束

配置

编写注解类

你可能感兴趣的:(Spring（二）)