栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring-记录

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring-记录

Spring 介绍 简介
	Spring框架以interface21框架为基础,经过重新设计,并不断丰富其内涵,于2004年3月24日发布了1.0正式版。
设计理念
	使现有的技术更加容易使用,本身是一个大杂烩,整合了现有的技术框架(为了简化开发的复杂性)。
Spring Maven依赖
https://search.maven.org/artifact/org.springframework/spring/5.3.20/pom
优点
丶 Spring是一个开源框架(容器)
丶 Spring是一个轻量级、非侵入式的框架
丶 控制反转(IOC)、面向切面编程(AOP)
丶 支持事务的处理,对框架整合的支持
官方文档
https://docs.spring.io/spring-framework/docs/current/reference/html
基本内容 组成模块
丶 SpringORM :对象映射支持
丶 SpringAOP :面向切面编程
丶 SpringDAO :对dao层的支持
丶 SpringWeb :WebApplicationContext
丶 SpringContext :界面、EJB等框架的支持
丶 SpringWebMVC :SpringMVC
丶 SpringCore :提供spring框架的基本功能。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QkMirgxZ-1655440315671)(newSpring.assets/image-20220522194322083.png)]

拓展 SpringBoot
丶 一个快速开发的脚手架
丶 基于SpringBoot可以快速的开发单个微服务
丶 约定大于配置(如maven)
SpringClound
丶 SpringClound是基于SpringBoot实现的
IOC理论 传统方式
public interface UserDao {
    String getName();
}

public class UserDaoImp implements UserDao{
    public String getName() {
        return "读mysql";
    }
}

public interface UserService {
    String getUserName();
}

public class UserServiceImp implements UserService{
    //这个地方的定死的
    UserDao user = new UserDaoImp();

    public String getUserName() {
        return user.getName();
    }
}

public class MyTest {
    //传统方式
    public static void main(String[] args) {
        UserService userService = new UserServiceImp();
        //调用dao层方法
        //缺陷是不读mysql时需要修改Service层代码
        System.out.println(userService.getUserName());
    }
}
注入方式
public interface UserDao {
    String getName();
}

public class NewUserDaoImp implements UserDao{
    public String getName() {
        return "读oracle";
    }
}

public interface NewUserService {
    //通过set注入User
    void setUser(UserDao user);

    String getUserName();
}

public class NewUserServiceImp implements NewUserService{
    UserDao user;

    //好处是当拓展userdao的实现类并需要使用时,不需要再修改service层原代码
    public void setUser(UserDao user) {
        this.user = user;
    }

    public String getUserName() {
        return user.getName();
    }
}

public class NewMyTest {
    public static void main(String[] args) {
        NewUserService service = new NewUserServiceImp();
        //将user的确定提到了用户层,让用户来确定参数
        service.setUser(new NewUserDaoImp());
        System.out.println(service.getUserName());
    }
}
说明
	这种思想,从本质上解决了问题,我们程序员不用再去管理对象的创建了。系统的耦合性大大降低了,可以更加专注在业务层上。(IOC的原型)
本质区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bTjhs1bq-1655440315673)(newSpring.assets/image-20220523214552465.png)]

IOC和Spring
	IOC是Spring框架的核心内容。控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式,在Spring中实现控制反转的是IOC容器,其实现方法是依赖注入。
Spring实例化容器 容器对象
	ApplicationContext(service层配置文件,dao层配置文件)
	
	
介绍:
	容器用户管理bean对象。这些bean是通过xml文件等方式创建的。在容器中bean定义表示为BeanDefinition对象。
	
bean对象的元数据信息(下面的这些属性信息在bean的定义中描述):
丶 一个包限定的类名(通常是被定义bean的模版类)
丶 bean的行为配置元素,它说明bean在容器中的行为方式(范围、声明回调等)
丶 对bean完成工作所需的其他bean的引用。这些引用也称为作者或依赖项
丶 要在新创建的对象中设置其他配置参数(如池的大小限制、管理连接池的bean中使用的连接数)
基于XML的配置文件 基本格式



      
        
        //class如果是内部类,内部类名称前面接$或.
    

    
        
    

    


配置文件中再导入配置文件


    
    //其他文件路径相对于执行导入的定义文件
    
    

    
    

Bean的配置
Class:实例化bean模版
Name:命名bean
Scope:bean的作用域
Constructor arguments:构造参数依赖注入
Properties:属性依赖注入
Autowiring mode:自动装配模式
lazy initialization mode:
initialization method:
Destruction method:
自动装配模式
模式参数:
no  →  (默认)不自动转配。bean引用必须有ref元素定义。对于较大的部署,不建议更改默认设置,因为明确指定协作者可以提供更大的控制力和清晰度。在某种程度上,它记录了系统的结构。

byName  →  按属性名称自动装配。Spring 寻找与需要自动装配的属性同名的 bean。例如,如果一个 bean 定义被设置为按名称自动装配并且它包含一个master属性(即它有一个 setMaster(..)方法),那么 Spring 会查找一个命名的 bean 定义master并使用它来设置该属性。

byType  →  如果容器中恰好存在一个属性类型的 bean,则让属性自动装配。如果存在多个,则会抛出一个致命异常,这表明您可能不会byType对该 bean 使用自动装配。如果没有匹配的 bean,则不会发生任何事情(未设置属性)。

constructor  →  类似于byType但适用于构造函数参数。如果容器中没有一个构造函数参数类型的 bean,则会引发致命错误。
在容器外部创建bean
介绍:
	上边的方式是在容器内部创建对象。在外部创建类:通过Application的getBeanFactory()方法访问ApplicationContext的BeanFactory(DefaultListableBeanFactory),通过其registerSingleton(..)、registerBeanDefinition(..)方法定义。
命名bean 介绍
	基于xml的配置方式可以使用id、name属性指定bean的标识符。id指向一个确定的id(一般使用驼峰命名法),name属性可以有多个(相当于别名,多个之间用,或;或空格分隔)。如果都未设置容器会为bean生成一个唯一的名称,通过ref元素或定位器查找。
在bean的定义之外命名bean
fromName的别名为toName(并非修改)
参数注入 构造函数注入参数

    
    	//默认自动根据类型判断参数顺序;也可以加个index属性指定索引位置;也可以使用name属性指定形参的名称(或者对应set方法的名称)来确定参数位置;还可以给类的构造方法加上注解@ConstructorProperties来指定参数,参数是字符串,名称是已定义的class的id
    	//构造函数指定基本数据类型参数
    	
    	
    	//构造函数的参数,引用类型的参数通过ref指定
        
        
        
    

    

    

setter方法注入参数
略


1.请注意,在 setter 方法上使用@Required 注释可用于使属性成为必需的依赖项
内部bean(内部类)
//内部bean不需要指定id或name,指定了容器也不会使用它作为标识符


    
    
         
            
            
        
    

bean继承 优点
	一个 bean 定义可以包含很多配置信息,包括构造函数参数、属性值和特定于容器的信息,例如初始化方法、静态工厂方法名称等。子 bean 定义从父定义继承配置数据。子定义可以根据需要覆盖某些值或添加其他值。使用父子bean定义可以节省大量输入。实际上,这是一种模板形式。
内容
//parent指向父类,子类中的值会覆盖父类中的值(子类必须与父类兼容)


    
    


  
    
    

数组注入

	
		
		......
	

集合注入
//映射键或值或设置值的值也可以是以下任何元素:bean | ref | idref | list | set | map | props | value | null

//表示空值


    
    
        
            administrator@example.org
            support@example.org
            development@example.org
        
    
    
    
        
            a list element followed by a reference
            
        
    
    
    
        
            
            
        
    
    
    
        
            just some string
            
        
    

其他方式注入 p命名空间注入


c命名空间注入


定义bean的范围 定义方式

范围 singleton
默认;定义为spring容器的单例bean。
只有一个单例 bean 的共享实例被管理,并且所有对具有与该 bean 定义匹配的一个或多个 ID 的 bean 的请求都会导致 Spring 容器返回一个特定的 bean 实例。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sHB5oYFM-1655440315673)(newSpring.assets/image-20220528105112269.png)]

propotype
原型;bean没有限制。
bean 部署的非单例原型范围导致每次对特定 bean 发出请求时都会创建一个新的 bean 实例。也就是说,将 bean 注入到另一个 bean 中,或者您通过getBean()容器上的方法调用来请求它。通常,您应该对所有有状态 bean 使用原型范围,对无状态 bean 使用单例范围。(数据访问对象 (DAO) 通常不配置为原型,因为典型的 DAO 不保存任何会话状态。我们更容易重用单例图的核心。)

注意:
1. Spring不管理原型bean的完整生命周期,不会调用配置的销毁生命周期回调。客户端代码必须清理原型范围非对象,并释放资源。(可以自定义bean后处理器)
2. 单例bean依赖于原型bean时,依赖注入原型bean时,该原型bean唯一(因为只发生一次注入)。如果使用方法注入可以使原型bean不唯一。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-blEZvCju-1655440315674)(newSpring.assets/image-20220528105428977.png)]

request
请求;将单个 bean 定义限定为单个 HTTP 请求的生命周期。也就是说,每个 HTTP 请求都有自己的 bean 实例,该实例是在单个 bean 定义的后面创建的。仅在 Web 感知 Spring 的上下文中有效ApplicationContext。
session
会话;将单个 bean 定义限定为 HTTP 的生命周期Session。仅在 Web 感知 Spring 的上下文中有效ApplicationContext。
application
将单个 bean 定义限定为ServletContext. 仅在 Web 感知 Spring 的上下文中有效ApplicationContext。
websocket
将单个 bean 定义限定为WebSocket. 仅在 Web 感知 Spring 的上下文中有效ApplicationContext。
将范围bean转化成单例bean 思想
代理的方式;如果你想(例如)将一个 HTTP 请求范围的 bean 注入到另一个具有更长生命周期的 bean 中,你可以选择注入一个 AOP 代理来代替这个范围 bean。也就是说,您需要注入一个代理对象,该对象公开与作用域对象相同的公共接口,但也可以从相关作用域(例如 HTTP 请求)检索真实目标对象,并将方法调用委托给真实对象。
语法



    
    
        
         
    

    
    
        
        
    

语法介绍
您还可以在范围的 bean 之间使用singleton,然后引用通过可序列化的中间代理,因此能够在反序列化时重新获取目标单例 bean。

当针对范围的 bean声明时prototype,共享代理上的每个方法调用都会导致创建一个新的目标实例,然后将调用转发到该实例。

此外,作用域代理并不是以生命周期安全的方式从较短的作用域访问 bean 的唯一方法。您还可以将您的注入点(即构造函数或 setter 参数或自动装配字段)声明为ObjectFactory,从而允许getObject()在每次需要时调用以按需检索当前实例 - 无需保留实例或单独存储它。
代理类型
1. 默认情况下,当 Spring 容器为使用元素标记的 bean 创建代理时,会创建基于 CGLIB 的类代理。
2. 或者,您可以配置 Spring 容器,通过指定元素的属性false值,为此类作用域 bean 创建基于标准 JDK 接口的代理。使用基于 JDK 接口的代理意味着您不需要应用程序类路径中的其他库来影响此类代理。但是,这也意味着作用域 bean 的类必须实现至少一个接口,并且注入作用域 bean 的所有协作者都必须通过其接口之一引用该 bean。以下示例显示了基于接口的代理:proxy-target-class

JDK代理



    



    

自定义范围 步骤
1. 实现接口 org.springframework.beans.factory.config.Scope
2. 处理对象;有四种方法 Object get(String name, ObjectFactory objectFactory)、Object remove(String name)、void registerDestructionCallback(String name, Runnable destructionCallback)(这个方法注册了一个回调,当作用域被销毁或作用域中的指定对象被销毁时应调用该回调)、String getConversationId()(这个方法获取基础范围的对话标识符,这个标识符对于每个范围都是不同的。对于会话范围的实现,此标识符可以是会话标识符。)
3. 注册;在ConfigurableBeanFactory接口(可使用BeanFactory)上的 void registerScope(String scopeName, Scope scope);参数一是与范围关联的唯一名称(如:singleton),第二个参数是自定义实际实例。(也可以使用基于xml的注册方式)
基于xml的注册





    
        
            
                
                    
                
            
        
    

    
        
        
    

    
        
    


IOC创建对象的方式
IOC默认通过无参构造创建类,如果没有无参构造会报错。如果需要使用有参构造要使用构造函数注入参数。
自动装配 介绍
	上面的方式是通过xml的方式显示的注入参数,而自动装配指的是不需要手动声明bean的参数,spring容器自动去寻找匹配的参数(一般是引用类型的参数)。
语法


自动装配的类型 no
	(默认)不自动装配。Bean 引用必须由ref元素定义。对于较大的部署,不建议更改默认设置,因为明确指定协作者可以提供更大的控制力和清晰度。在某种程度上,它记录了系统的结构。
byName
	按属性名称自动装配。Spring 寻找与需要自动装配的属性同名的 bean。例如,如果一个 bean 定义被设置为按名称自动装配并且它包含一个master属性(即,它有一个 setMaster(..)方法),那么 Spring 会查找一个命名的 bean 定义master并使用它来设置属性。
byType
	如果容器中恰好存在一个属性类型的 bean,则让属性自动装配。如果存在多个,则会抛出一个致命异常,这表明您可能不会byType对该 bean 使用自动装配。如果没有匹配的 bean,则不会发生任何事情(未设置属性)。
constructor
	类似于byType但适用于构造函数参数。如果容器中没有一个构造函数参数类型的 bean,则会引发致命错误。
使用容器 检索对象
ApplicationContext{ClassPathXmlApplicationContext(基于java类的配置方式),FileSystemXmlApplicationContext(基于xml的配置方式)}
getBean(String name, Class requiredType);
Spring注解开发 前提





    


注解 容器配置↓ @Required 语法
public class SimpleMovieLister {

    private MovieFinder movieFinder;

    @Required
    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }

    // ...
}
解释
	此注解指示必须在配置时通过 bean 定义中的显式属性值或通过自动装配来填充受影响的 bean 属性。如果受影响的 bean 属性尚未填充,则容器将引发异常。这允许急切和明确NullPointerException 的失败,避免以后出现实例等。我们仍然建议您将断言放入 bean 类本身(例如放入 init 方法)。即使您在容器外部使用类,这样做也会强制执行这些必需的引用和值。
	作用是用于方法注入(根据类型和名称,set方法注入),即“自动装配”。
@Autowired 语法
public class MovieRecommender {

    private final CustomerPreferenceDao customerPreferenceDao;

    @Autowired
    public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {
        this.customerPreferenceDao = customerPreferenceDao;
    }

    // ...
}
解释
	默认是根据beanName自动装配,没有就根据类型。可用于构造方法注入、方法注入、属性注入。
	如果required=false说明,值可以为null
@Primary 语法
@Configuration
public class MovieConfiguration {

    @Bean
    @Primary
    public MovieCatalog firstMovieCatalog() { ... }

    @Bean
    public MovieCatalog secondMovieCatalog() { ... }

    //解释:当上面两个方法调用之后会产生bean,bean都放到容器中时,使用自动装配这个类型时会有两个对象与之对应,正常情况下会报错。@Primary的作用就是指定主要的对象,使其不报错。
}
解释
	由于按类型自动装配可能会导致多个候选者,因此通常需要对选择过程进行更多控制。实现这一点的一种方法是使用 Spring 的 @Primary注释。@Primary指示当多个 bean 是自动装配到单值依赖项的候选对象时,应该优先考虑特定的 bean。如果候选中恰好存在一个主 bean,则它将成为自动装配的值。
@Qualifier 语法
public class MovieRecommender {

    private MovieCatalog movieCatalog;

    private CustomerPreferenceDao customerPreferenceDao;

    @Autowired
    public void prepare(@Qualifier("main") MovieCatalog movieCatalog,
            CustomerPreferenceDao customerPreferenceDao) {
        this.movieCatalog = movieCatalog;
        this.customerPreferenceDao = customerPreferenceDao;
    }

    // ...
}
解释
	在自动装配的过程中存在多个bean,@Qualifier的作用是缩小选择的范围,参数是bean的名称或限定符。还有其他用法参考官网。
CustomAutowireConfigurer(自定义限定符) 语法

    
        
            example.CustomQualifier
        
    

限定符如何发挥作用
不太清楚?
通过以下AutowireCandidateResolver方式确定自动接线候选者:
	丶 autowire-candidate每个bean定义的值
	丶 元素default-autowire-candidates上可用的任何模式
	丶 注释的存在@Qualifier和任何注册的自定义注释CustomAutowireConfigurer
当多个 bean 有资格成为自动装配候选者时,“主要”的确定如下:如果候选者中恰好一个 bean 定义的primary 属性设置为true,则选择它。
@Resource 语法
public class SimpleMovieLister {

    private MovieFinder movieFinder;

    @Resource(name="myMovieFinder") 
    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }
}
解释
	@Resource采用名称属性。默认情况下,Spring 将该值解释为要注入的 bean 名称。
	如果没有明确指定名称,则默认名称派生自字段名称或 setter 方法。如果是字段,则采用字段名称。对于 setter 方法,它采用 bean 属性名称。
@Value 语法
@Component
public class MovieRecommender {

    private final String catalog;

    public MovieRecommender(@Value("${catalog.name}") String catalog) {
        this.catalog = catalog;
    }
}

加载配置文件

@Configuration
@PropertySource("classpath:application.properties")
public class AppConfig { }

配置文件

catalog.name=MovieCatalog
解释
@Value通常用于注入外部属性:
Spring 提供的内置转换器支持允许自动处理简单的类型转换(toInteger 或example)。int多个逗号分隔的值可以自动转换为String数组,无需额外的努力。
自定义解析器(类型转换)
//?(不理解,以后再搞)
@Configuration
public class AppConfig {

    @Bean
    public ConversionService conversionService() {
        DefaultFormattingConversionService conversionService = new DefaultFormattingConversionService();
        conversionService.addConverter(new MyCustomConverter());
        return conversionService;
    }
}
类路径扫描和托管组件↓ @Component 语法
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component 
public @interface Service {

    // ...
}
解释
	Spring 提供了更多的原型注解:@Component、@Service和 @Controller. @Component是任何 Spring 管理的组件的通用构造型。 @Repository, @Service, 和@Controller是@Component针对更具体用例(分别在持久层、服务层和表示层)的特化。因此,您可以使用 注释组件类 @Component,但是通过使用 、 注释它们@Repository,@Service或者@Controller 相反,您的类更适合工具处理或与方面关联。例如,这些原型注释是切入点的理想目标。@Repository, @Service, 并且@Controller还可以在 Spring 框架的未来版本中携带额外的语义。因此,如果您在使用@Component或者@Service对于你的服务层,@Service显然是更好的选择。同样,如前所述,@Repository已经支持作为持久层中自动异常转换的标记。
说明
@Component有几个衍生注解,在web开发中,会按照mvc三层架构分层:
dao【@Repository】
service【@Service】
controller【@Controller】
	意思都是代表将类注册到spring容器中。(需要配合组件扫描使用)
@Configuration 语法
@Configuration
@ComponentScan(basePackages = "org.example")
public class AppConfig  {
    // ...
}



    


解释
	@ComponentScan是配置组件扫描的路径。@Configuration表示这是一个配置类,相当于xml配置文件。(AnnotationConfigApplicationContext)
@Import
@Configuration
@Import(Config2.class)	//在一个配置类中引入另一个配置类
public class Config1{
    ...
}
设置过滤器
@Configuration
@ComponentScan(basePackages = "org.example",
        includeFilters = @Filter(type = FilterType.REGEX, pattern = ".*Stub.*Repository"),
        excludeFilters = @Filter(Repository.class))
public class AppConfig {
    // ...
}

    
        
        
    

过滤器类型
类型			示例表达式			描述

annotation(default) 	

assignable


aspectj(面向切面编程)


regex(正则) org.example.Default.*  与类名匹配的正则表达式。


custom(自定义)	 org.example.MyTypeFilter	继承TypeFilter类
@Bean 语法
@Component
public class FactoryMethodComponent {

    @Bean
    @Qualifier("public")
    public TestBean publicInstance() {
        return new TestBean("publicInstance");
    }

    public void doWork() {
        // Component method implementation omitted
    }
}
解释
	@Bean用于在一个产生bean的方法上。作用是产生bean,产生的bean的id是方法的名字。
@Scope 语法
@Component
@Scopre("singleton")
public class SimpleMovieLister {
    private MovieFinder movieFinder;

}
解释
	设置bean的范围。
@RestController 介绍
	用在类上,表示一个controller类,并且这个类下的所有方法都返回字符串,而不去找对应的jsp。
@ResponseBody 介绍
	用在方法上,表示这个方法的返回值是一个字符串,不要去找对应的jsp。
xml与注解 区别
丶 xml更加万能,适用于任何场合!维护简单方便
丶 注解不是自己的类使用不了,维护相对复杂!
xml与注解的最佳实践
丶 xml用来管理bean
丶 注解只负责完成属性的注入
AOP 需要导入包


	org.aspectj
    aspectjweaver
    1.9.4

代理模式 介绍

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XU5WZjbB-1655440315675)(newSpring.assets/image-20220601190735268.png)]

静态代理 语法
//接口
public interface Send{
    public void send();
}

//对象
public class Rent implements Send {
    public void send(){
        system.out.print("对象输出")
    }
}


//代理对象
public class Aent implements Send {
    Rent rent;
    
    public Aent(Rent rent){
        this.rent = rent;
    }
    
    //一般而言代理对象会对普通对象进行附加操作,而代理对象的意义也在于此
    public void send(Rent rent){
        rent.send;
    }
}
动态代理 实现方式
丶 基于接口--JDK代理
丶 基于类--cglib
丶 java字节码--javasist
语法
//接口
public interface Aend {
    public void sair();
}


//真实对象
public class Bend implements Aend{
    public void sair() {
        System.out.println("hellow");
    }
}


//处理器  和静态代理不同的是这个类没有实现对应接口,是一个工具类,用来生产代理对象
public class Cend implements InvocationHandler {
    Object obj;

    public void setObj(Object obj){
        this.obj=obj;
    }

    //处理代理实例并返回结果,在这个方法中可以书写附加的方法(公共方法)
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //参数 → 代理对象 对象的方法 方法的参数
        return method.invoke(obj,args);
    }

    //创建一个代理对象
    public Object getProxy(){
        //参数 → 类加载器 真实对象实现的接口数组 InvocationHandler处理器
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
    }
}


//测试
public class MainTest {
    public static void main(String[] args) {
        //处理器
        Cend handle = new Cend();
        //真实对象
        Bend obj = new Bend();
        //获取代理对象
        handle.setObj(obj);
        Aend proxy = (Aend) handle.getProxy();
        proxy.sair();
    }
}
特点
	动态代理相对于静态代理的优点是:一个动态代理可以代理多个类
什么是AOP 介绍
	面向切面编程,通过与编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是spring框架中的一个重要内容,是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高开发效率。
一些专业术语 横切关注点
	跨越应用程序多个模块的方法或功能。与业务逻辑无关,但是需要关注的部分就是横切关注点。(如 日志、安全、缓存、事务等)
切面(Aspect)
	横切关注点被模块化的特殊对象。一个类。(代理类的附加功能)
通知(Advice)
	切面必须要完成的工作。(真实对象的方法)
目标(Target)
	被通知的对象。
代理(Proxy)
	向目标对象应用通知之后创建的对象。
切入点(PointCut)
	切面通知执行的地点。(真实对象的方法)
连接点(jointPoint)
	与切入点匹配的执行点。
SpringAOP的通知 前置通知
实现接口: org.springframework.aop.MethodBeforeAdvice
连接点:真实对象执行方法前
后置通知
实现接口:org.springframework.aop.AfterReturningAdvice
连接点:方法执行之后
环绕通知
实现接口:org.springframework.aop.MethodInterceptor
连接点:方式执行前后
异常抛出通知
实现接口:org.springframework.aop.ThrowsAdvice
连接点:方法抛出异常
引介通知
实现接口:org.springframework.aop.IntroduvtionInterceptor
连接点:类中增加新的方法属性
语法 xml方式 接口
public interface Real {
    public void work();
}
切点(真实对象)
public class RealImp implements Real{
    public void work() {
        System.out.println("处理业务逻辑  work...");
    }
}
前置处理器
public class BeforeLog implements MethodBeforeAdvice {
    //在业务逻辑方法之前调用
    public void before(Method method, Object[] args, Object target) throws Throwable {
        //参数  →  业务逻辑方法 参数 真实对象
        System.out.println("前置日志 before rizhi");
    }
}
后置处理器
public class AfterLog implements AfterReturningAdvice {
    //后置日志
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        //参数 → 真实方法执行的返回结果 真实方法 方法参数 真实对象
        System.out.println("后置日志 after rizhi");
    }
}
测试
public class AopTest {
    public static void main(String[] args) {
        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("test.xml");
        Real real = (Real) classPathXmlApplicationContext.getBean("real");
        real.work();
    }
}
xml文件



    
    
    
    
    
    
            
        
        
        
        
    

说明
丶 中文有乱码(未解决)
xml方式自定义切面 接口
public interface Real {
    public void work();
}
目标对象
public class RealImp implements Real{
    public void work() {
        System.out.println("处理业务逻辑  work...");
    }
}
切面
public class CustomAspect {
    public void after(){
        System.out.println("after ...");
    }

    public void before(){
        System.out.println("before ...");
    }
}
xml文件



    
    
    
    
    
    
        
            
            
            
        
    

测试
public class AopTest {
    public static void main(String[] args) {
        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("test.xml");
        Real real = (Real) classPathXmlApplicationContext.getBean("real");
        real.work();
    }
}
说明
	效果与上面的范式一致。
注解方式 接口
public interface Real {
    public void work();
}
目标对象
//注册类
@Repository("real")
public class RealImp implements Real{
    public void work() {
        System.out.println("处理业务逻辑  work...");
    }
}
自定义切面
@Aspect
@Component
public class CustomAspect {
    @After("execution(* DefaultDome1.ProxyTest.RealImp.*(..))")
    public void after(){
        System.out.println("after ...");
    }

    @Before("execution(* DefaultDome1.ProxyTest.RealImp.*(..))")
    public void before(){
        System.out.println("before ...");
    }
}
测试
@Configuration
@ComponentScan(basePackages="DefaultDome1.ProxyTest")
@EnableAspectJAutoProxy
//EnableAspectJAutoProxy → 需要开启自动代理
public class AopTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(AopTest.class);
        Real real = (Real) annotationConfigApplicationContext.getBean("real");
        real.work();
    }
}
    
        
    

~~~ 测试
public class AopTest {
    public static void main(String[] args) {
        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("test.xml");
        Real real = (Real) classPathXmlApplicationContext.getBean("real");
        real.work();
    }
}
说明
	效果与上面的范式一致。
注解方式 接口
public interface Real {
    public void work();
}
目标对象
//注册类
@Repository("real")
public class RealImp implements Real{
    public void work() {
        System.out.println("处理业务逻辑  work...");
    }
}
自定义切面
@Aspect
@Component
public class CustomAspect {
    @After("execution(* DefaultDome1.ProxyTest.RealImp.*(..))")
    public void after(){
        System.out.println("after ...");
    }

    @Before("execution(* DefaultDome1.ProxyTest.RealImp.*(..))")
    public void before(){
        System.out.println("before ...");
    }
}
测试
@Configuration
@ComponentScan(basePackages="DefaultDome1.ProxyTest")
@EnableAspectJAutoProxy
//EnableAspectJAutoProxy → 需要开启自动代理
public class AopTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(AopTest.class);
        Real real = (Real) annotationConfigApplicationContext.getBean("real");
        real.work();
    }
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/978770.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号