Spring基础（下）-阿里云开发者社区

注解开发

创建一个配置类：

@Configuration
public class MainConfiguration {
}

配置Bean：

@Configuration
public class MainConfiguration {
    @Bean("student")
    public Student student(){
        return new Student();
    }
}

获取Bean对象：

ApplicationContext context = new AnnotationConfigApplicationContext(MainConfiguration.class);
Student student = context.getBean(Student.class);
System.out.println(student);

其他属性配置：

@Bean(name = "", initMethod = "", destroyMethod = "", autowireCandidate = false)
public Student student(){
    return new Student();
}

@Bean
@Lazy(true)     //对应lazy-init属性
@Scope("prototype")    //对应scope属性
@DependsOn("teacher")    //对应depends-on属性
public Student student(){
    return new Student();
}

通过构造方法或是Setter完成依赖注入的Bean：

@Configuration
public class MainConfiguration {
    @Bean
    public Teacher teacher(){
        return new Teacher();
    }
    @Bean
    public Student student(Teacher teacher){
        return new Student(teacher);
//        return new Student().setTeacher(teacher);
    }
}

直接到Bean对应的类中使用自动装配：

public class Student {
    @Autowired   //使用此注解来进行自动装配，由IoC容器自动为其赋值
    private Teacher teacher;
}

甚至连构造方法和Setter都不需要去编写了，就能直接完成自动装配

@Autowired并不是只能用于字段，对于构造方法或是Setter，它同样可以：

public class Student {
    private Teacher teacher;
    @Autowired
    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }
}

@Autowired默认采用byType的方式进行自动装配

发生歧义时配合@Qualifier进行名称匹配：

public class Student {
    @Autowired
    @Qualifier("a")   //匹配名称为a的Teacher类型的Bean
    private Teacher teacher;
}

@Resource，它的作用与@Autowired时相同的，也可以实现自动装配，但是在IDEA中并不推荐使用@Autowired注解对成员字段进行自动装配，而是推荐使用@Resource，如果需要使用这个注解，还需要额外导入包：

<dependency>
    <groupId>jakarta.annotation</groupId>
    <artifactId>jakarta.annotation-api</artifactId>
    <version>2.1.1</version>
</dependency>

@Resource默认ByName如果找不到则ByType，可以添加到set方法、字段上。
@Autowired默认是byType，只会根据类型寻找，可以添加在构造方法、set方法、字段、方法参数上。

@PostConstruct和@PreDestroy，它们效果和init-method和destroy-method是一样的：

@PostConstruct
public void init(){
    System.out.println("我是初始化方法");
}
@PreDestroy
public void destroy(){
    System.out.println("我是销毁方法");
}

使用@Bean来注册Bean，只是简单将一个类作为Bean的话，就是单纯的new一个对象出来，不能像之前一样让容器自己反射获取构造方法去生成这个对象

@Component注册Bean：

@Component("lbwnb")   //同样可以自己起名字
public class Student {
}

配置一下包扫描：

@Configuration
@ComponentScan("com.test.bean")   //包扫描，这样Spring就会去扫描对应包下所有的类
public class MainConfiguration {
}

Spring在扫描对应包下所有的类时，会自动将那些添加了@Component的类注册为Bean

无论是通过@Bean还是@Component形式注册的Bean，Spring都会为其添加一个默认的name属性

@Component默认名称生产规则依然是类名并按照首字母小写的驼峰命名法来的

@Component
public class Student {
}

Student student = (Student) context.getBean("student");   //这样同样可以获取到
System.out.println(student);

@Bean注册的默认名称是对应的方法名称

@Bean
public Student artStudent(){
    return new Student();
}

Student student = (Student) context.getBean("artStudent");
System.out.println(student);

@Component注册的Bean，如果其构造方法不是默认无参构造，那么默认会对其每一个参数都进行自动注入：

Spring也提供了接口，我们可以直接实现接口表示这个Bean是一个工厂Bean：

@Component
public class StudentFactory implements FactoryBean<Student> {
    @Override
    public Student getObject() {   //生产的Bean对象
        return new Student();
    }
    @Override
    public Class<?> getObjectType() {   //生产的Bean类型
        return Student.class;
    }
    @Override
    public boolean isSingleton() {   //生产的Bean是否采用单例模式
        return false;
    }
}

AOP面向切片

AOP（Aspect Oriented Programming）思想实际上就是：在运行时，动态地将代码切入到类的指定方法、指定位置上。

可以使用AOP来帮助我们在方法执行前或执行之后，做一些额外的操作，实际上，它就是代理。

通过AOP我们可以在保证原有业务不变的情况下，，在不改变源代码的基础上进行了增强处理。

aop环境建立：

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

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>6.0.10</version>
</dependency>

配置实现AOP

实体类：

public class Student {
    public void study(){
        System.out.println("狠狠的学Java");
    }
}

代理类：

public class StudentAOP {
    public void afterStudy(){
        System.out.println("hahahaha");
    }
}

Bean注册：

    <bean class="com.test.entity.Student"/>
    <bean id="studentAop" class="com.test.entity.StudentAOP"/>
    <aop:config>
        <aop:pointcut id="test" expression="execution(public void com.test.entity.Student.study())"/>
        <aop:aspect ref="studentAop">
            <aop:after method="afterStudy" pointcut-ref="test"/>
        </aop:aspect>
    </aop:config>

调用效果：

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("test.xml");
        Student bean = context.getBean(Student.class);
        bean.study();
    }
}

说明：

实体和代理类都得注册为Bean，然后进行aop配置

添加一个新的切点，首先填写ID，再通过后面的expression表达式来选择到我们需要切入的方法

Spring AOP支持以下AspectJ切点指示器（PCD）用于表达式：

execution：用于匹配方法执行连接点。这是使用Spring AOP时使用的主要点切割指示器。
within：限制匹配到某些类型的连接点（使用Spring AOP时在匹配类型中声明的方法的执行）。
this：限制与连接点匹配（使用Spring AOP时方法的执行），其中bean引用（Spring AOP代理）是给定类型的实例。
target：限制匹配连接点（使用Spring AOP时方法的执行），其中目标对象（正在代理的应用程序对象）是给定类型的实例。
args：限制与连接点匹配（使用Spring AOP时方法的执行），其中参数是给定类型的实例。
@target：限制匹配连接点（使用Spring AOP时方法的执行），其中执行对象的类具有给定类型的注释。
@args：限制匹配到连接点（使用Spring AOP时方法的执行），其中传递的实际参数的运行时类型具有给定类型的注释。
@within：限制与具有给定注释的类型中的连接点匹配（使用Spring AOP时在带有给定注释的类型中声明的方法的执行）。
@annotation：与连接点主体（在Spring AOP中运行的方法）具有给定注释的连接点匹配的限制。

execution填写格式如下：

修饰符 包名.类名.方法名称(方法参数)

修饰符：public、protected、private、包括返回值类型、static等等（使用*代表任意修饰符）
包名：如com.test（* 代表全部，比如com.*代表com包下的全部包）
类名：使用*也可以代表包下的所有类
方法名称：可以使用*代表全部方法
方法参数：填写对应的参数即可，比如(String, String)，也可以使用*来代表任意一个参数，使用…代表所有参数。

添加aop:aspect标签，并使用ref属性将其指向我们刚刚注册的AOP类Bean

添加后续动作了，当然，官方支持的有多种多样的，比如执行前、执行后、抛出异常后、方法返回后等等

Spring通过CGLib为我们生成的动态代理类，使得调用方法会直接得到增强

JoinPoint信息获取：

对于切入的方法添加一个JoinPoint参数，通过此参数就可以快速获取切点位置的一些信息：

public class Student {
    public void study(String str){
        System.out.println("狠狠的学"+str);
    }
}
public class StudentAOP {
    public void afterStudy(JoinPoint point){
        System.out.println("hahahaha"+point.getArgs()[0]+"无敌");
    }
}
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("test.xml");
        Student bean = context.getBean(Student.class);
        bean.study("java");
    }
}

<aop:pointcut id="test" expression="execution(public void com.test.entity.Student.study(String))"/>//指定具体参数类型
<aop:pointcut id="test" expression="execution(public void com.test.entity.Student.study(..))"/>//模糊代指

环绕方法：

环绕方法相当于完全代理了此方法，它完全将此方法包含在中间，需要我们手动调用才可以执行此方法，并且我们可以直接获取更多的参数

通过proceed方法来执行代理的方法，也可以修改参数之后调用proceed(Object[])，在调用之后对返回值结果也进行处理

    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("before");
        String arg = joinPoint.getArgs()[0]+"666";
        Object ret = joinPoint.proceed(new Object[]{arg});
        System.out.println("after");
        return ret;
    }

        <aop:aspect ref="studentAop">
            <aop:around method="around" pointcut-ref="test"/>
        </aop:aspect>

AOP 领域中的特性术语：

通知（Advice）: AOP 框架中的增强处理，通知描述了切面何时执行以及如何执行增强处理，也就是我们上面编写的方法实现。
连接点（join point）: 连接点表示应用执行过程中能够插入切面的一个点，这个点可以是方法的调用、异常的抛出，实际上就是我们在方法执行前或是执行后需要做的内容。
切点（PointCut）: 可以插入增强处理的连接点，可以是方法执行之前也可以方法执行之后，还可以是抛出异常之类的。
切面（Aspect）: 切面是通知和切点的结合，我们之前在xml中定义的就是切面，包括很多信息。
引入（Introduction）：引入允许我们向现有的类添加新的方法或者属性。
织入（Weaving）: 将增强处理添加到目标对象中，并创建一个被增强的对象，我们之前都是在将我们的增强处理添加到目标对象，也就是织入

接口实现AOP

将一个类实现Advice接口，只有实现此接口，才可以被通知

使用MethodBeforeAdvice表示是一个在方法执行之前的动作；AfterReturningAdvice就需要实现一个方法执行之后的操作

public class StudentAOP implements MethodBeforeAdvice, AfterReturningAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("before:");
    }
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("after-return");
    }
}

        <aop:advisor advice-ref="studentAop" pointcut-ref="test"/>

使用MethodInterceptor（同样也是Advice的子接口）进行更加环绕那样的自定义的增强

public class StudentAOP implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("haha");
        Object ret = invocation.proceed();
        System.out.println("wuwu");
        return ret;
    }
}

注解实现AOP

实体类：

@Component//注册为Bean
public class Student {
    public void study(String str){
        System.out.println("狠狠的学"+str);
    }
}

代理类：

@Aspect//声明为切面
@Component//注册为Bean
public class StudentAOP {
    @Before("execution(* com.test.entity.Student.study(..))")
    public void before(JoinPoint point){
        System.out.println("before");
        System.out.println("args:"+Arrays.toString(point.getArgs()));
    }
    @After(value = "execution(* com.test.entity.Student.study(..)) && args(str)",argNames = "str")
    //命名绑定模式就是根据下面的方法参数列表进行匹配
//这里args指明参数，注意需要跟原方法保持一致，然后在argNames中指明
    public void after(String str){//获取指定参数
        System.out.println("get arg str:" + str);
        System.out.println("after");
    }
}

配置类：

@EnableAspectJAutoProxy//开启aop代理
@ComponentScan("com.test.entity")//扫描bean实体类
@Configuration//声明配置类
public class MainConfiguration {
}

调用：

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(MainConfiguration.class);
        Student bean = context.getBean(Student.class);
        bean.study("java");
    }
}

除了@Before，还有很多可以直接使用的注解，比如@AfterReturning、@AfterThrowing等

环绕注解：

@Around("execution(* com.test.bean.Student.test(..))")
public Object around(ProceedingJoinPoint point) throws Throwable {
    System.out.println("方法执行之前！");
    Object val = point.proceed();
    System.out.println("方法执行之后！");
    return val;
}

void after(String str){//获取指定参数

System.out.println(“get arg str:” + str);

System.out.println(“after”);

}

配置类：
~~~java
@EnableAspectJAutoProxy//开启aop代理
@ComponentScan("com.test.entity")//扫描bean实体类
@Configuration//声明配置类
public class MainConfiguration {
}

调用：

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(MainConfiguration.class);
        Student bean = context.getBean(Student.class);
        bean.study("java");
    }
}

除了@Before，还有很多可以直接使用的注解，比如@AfterReturning、@AfterThrowing等

环绕注解：

@Around("execution(* com.test.bean.Student.test(..))")
public Object around(ProceedingJoinPoint point) throws Throwable {
    System.out.println("方法执行之前！");
    Object val = point.proceed();
    System.out.println("方法执行之后！");
    return val;
}

Spring基础（下）

注解开发

AOP面向切片

配置实现AOP

接口实现AOP

注解实现AOP

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Spring基础（下）

注解开发

AOP面向切片

配置实现AOP

接口实现AOP

注解实现AOP

热门文章

最新文章

相关课程

相关电子书

相关实验场景