Spring 框架常用语法进行总结

标签：描述   cal   生命周期   包括   依赖关系   面向切面   prototype   break   sign   

Spring 框架常用语法进行总结：

spring框架的二大主要的功能就是IOC和AOP。

IOC: 控制反转（依赖注入）

AOP: 面向切面编程

学习spring最好的方法就是去看官网，里面有详细的说明及使用原则

介绍spring 中的注解的使用，xml配置等目前在市面上面较少。

首先介绍Java自带的元注解 (元注解就是 能注解到注解上的注解，能用在其他注解上的注解 )

Java5.0定义了4个标准的meta-annotation类型

@Target ：

用于描述注解的范围，即注解在哪用。它说明了Annotation所修饰的对象范围：Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）等。取值类型（ElementType）

   CONSTRUCTOR:用于描述构造器
　　FIELD:用于描述域即类成员变量
　　LOCAL_VARIABLE:用于描述局部变量
　　METHOD:用于描述方法
　　PACKAGE:用于描述包
　　PARAMETER:用于描述参数
　　TYPE:用于描述类、接口(包括注解类型) 或enum声明
　　TYPE_PARAMETER:1.8版本开始，描述类、接口或enum参数的声明
　　TYPE_USE:1.8版本开始，描述一种类、接口或enum的使用声明
　　

eg :
?
public @interface Log {
    ......
}

@Retention ：

用于描述注解的生命周期，表示需要在什么级别保存该注解，即保留的时间长短。取值类型RetentionPolicy)

   SOURCE:在源文件中有效（即源文件保留）
　　CLASS:在class文件中有效（即class保留）
　　RUNTIME:在运行时有效（即运行时保留）  

eg:
?
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
　　......
}

@Documented ：

用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。它是一个标记注解，没有成员。

eg :
?
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {
　　......
}

@Inherited :

用于表示某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。

Spring 常用的注解

在注解配置中常用的启动方法就是：

<！--在XML中启用方法-->
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Person bean = (Person) applicationContext.getBean("person");
System.out.println(bean);

--------------------------------------------------------------------------
    <！--在注解中启用方法-->
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
Person bean = applicationContext.getBean(Person.class);
System.out.println(bean);


getBeanNamesForType:得到当前IOC容器加载进来的bean的名称
String[] namesForType = applicationContext.getBeanNamesForType(Person.class);
for (String name : namesForType) {
System.out.println(name);
}

@Component

组件，没有明确的角色

@Service

在业务逻辑层使用（service层）

@Repository

在数据访问层使用（dao层）

@Controller

在展现层使用，控制器的声明（Controller）

@Bean

注入ioc容器中，默认是以方法的名称作为注入容器里面的名称，需注意@bean可以不在配置类里面使用，不过经过@Bean注解使用过的方法所在的类也会被加载到ioc容器里面。

//配置类==配置文件

@Configuration

告诉Spring这是一个配置类,用在一个类的上面，配置类

@Configuration == <bean id="person" class="com.opendev.entity.Person"></bean>

@ComponentScan

value:指定要扫描的包，用在配置类上面，告诉程序在spring中的扫包范围

@ComponentScans

扫描多个包还有提供扫包的自定义扫包规则

package com.atguigu.config;
?
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.ComponentScans;
?
import com.atguigu.bean.Person;
?
//配置类==配置文件
@Configuration  //告诉Spring这是一个配置类
?
@ComponentScans(
value = {
@ComponentScan(value="com.atguigu",includeFilters = {
/*@Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
@Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),*/
@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
},useDefaultFilters = false)
}
)
//@ComponentScan  value:指定要扫描的包
//excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件
//includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件
//FilterType.ANNOTATION：按照注解
//FilterType.ASSIGNABLE_TYPE：按照给定的类型；
//FilterType.ASPECTJ：使用ASPECTJ表达式
//FilterType.REGEX：使用正则指定
//FilterType.CUSTOM：使用自定义规则
public class MainConfig {

//给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
@Bean("person")//声明了注入ioc容器里面的对象为person,默认都是以方法名作为id
public Person person01(){
return new Person("lisi", 20);
}
}
?

//类中组件统一设置。满足当前条件，这个类中配置的所有bean注册才能生效；

@Conditional

里面需要写上相应接口的实现类

@Import

导入组件，id默认是组件的全类名

spring中bean的作用域

默认是单实例的

//默认是单实例的
/**
 * ConfigurableBeanFactory#SCOPE_PROTOTYPE    
 * @see ConfigurableBeanFactory#SCOPE_SINGLETON  
 * @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST  request
 * @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION sesssion
 * @return\
 * @Scope:调整作用域
 * prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。
 * 每次获取的时候才会调用方法创建对象；
 * singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。
 * 以后每次获取就是直接从容器（map.get()）中拿，
 * request：同一次请求创建一个实例
 * session：同一个session创建一个实例
 * 
 * 懒加载：
 * 单实例bean：默认在容器启动的时候创建对象；
 * 懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；
 * 
 */
//@Scope("prototype")
@Lazy
@Bean("person")
public Person person(){
System.out.println("给容器中添加Person....");
return new Person("张三", 25);
}

spring中bean 的生命周期

/**
 * bean的生命周期：
 * bean创建---初始化----销毁的过程
 * 容器管理bean的生命周期；
 * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
 * 
 * 构造（对象创建）
 * 单实例：在容器启动的时候创建对象
 * 多实例：在每次获取的时候创建对象\
 * 
 * BeanPostProcessor.postProcessBeforeInitialization
 * 初始化：
 * 对象创建完成，并赋值好，调用初始化方法。。。
 * BeanPostProcessor.postProcessAfterInitialization
 * 销毁：
 * 单实例：容器关闭的时候
 * 多实例：容器不会管理这个bean；容器不会调用销毁方法；
 * 
 * 
 * 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization，
 * 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization
 * 
 * BeanPostProcessor原理
 * populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值
 * initializeBean
 * {
 * applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 * invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化
 * applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 *}
 * 
 * 
 * 
 * 1）、指定初始化和销毁方法；
 * 通过@Bean指定init-method和destroy-method；
 * 2）、通过让Bean实现InitializingBean（定义初始化逻辑），
 * DisposableBean（定义销毁逻辑）;
 * 3）、可以使用JSR250；
 * @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法
 * @PreDestroy：在容器销毁bean之前通知我们进行清理工作
 * 4）、BeanPostProcessor【interface】：bean的后置处理器；
 * 在bean初始化前后进行一些处理工作；
 * postProcessBeforeInitialization:在初始化之前工作
 * postProcessAfterInitialization:在初始化之后工作
 * 
 * Spring底层对 BeanPostProcessor 的使用；
 * bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async,xxx BeanPostProcessor;
 * 
 * 
 *
 */

spring中的自动装配

/**
 * 自动装配;
 * Spring利用依赖注入（DI），完成对IOC容器中中各个组件的依赖关系赋值；
 * 
 * 1）、@Autowired：自动注入：
 * 1）、默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class);找到就赋值
 * 2）、如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找
 * applicationContext.getBean("bookDao")
 * 3）、@Qualifier("bookDao")：使用@Qualifier指定需要装配的组件的id，而不是使用属性名
 * 4）、自动装配默认一定要将属性赋值好，没有就会报错；
 * 可以使用@Autowired(required=false);
 * 5）、@Primary：让Spring进行自动装配的时候，默认使用首选的bean；
 * 也可以继续使用@Qualifier指定需要装配的bean的名字
 * BookService{
 * @Autowired
 * BookDao  bookDao;
 * }
 * 
 * 2）、Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[java规范的注解]
 * @Resource:
 * 可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；
 * 没有能支持@Primary功能没有支持@Autowired（reqiured=false）;
 * @Inject:
 * 需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能；
 *  @Autowired:Spring定义的； @Resource、@Inject都是java规范
 * 
 * AutowiredAnnotationBeanPostProcessor:解析完成自动装配功能；
 * 
 * 3）、 @Autowired:构造器，参数，方法，属性；都是从容器中获取参数组件的值
 * 1）、[标注在方法位置]：@Bean+方法参数；参数从容器中获取;默认不写@Autowired效果是一样的；都能自动装配
 * 2）、[标在构造器上]：如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取
 * 3）、放在参数位置：
 * 
 * 4）、自定义组件想要使用Spring容器底层的一些组件（ApplicationContext，BeanFactory，xxx）；
 * 自定义组件实现xxxAware；在创建对象的时候，会调用接口规定的方法注入相关组件；Aware；
 * 把Spring底层一些组件注入到自定义的Bean中；
 * xxxAware：功能使用xxxProcessor；
 * ApplicationContextAware==》ApplicationContextAwareProcessor；
 * 
 * 
 * 
 *
 */

Spring 框架常用语法进行总结

标签：描述   cal   生命周期   包括   依赖关系   面向切面   prototype   break   sign   

原文地址：https://www.cnblogs.com/cb1186512739/p/11876823.html