项目中使用的spring 注解说明
SpringIoC公共注解详解
SpringIoC 公共注解详解前⾔本系列全部基于 Spring 5.2.2.BUILD-SNAPSHOT 版本。
因为 Spring 整个体系太过于庞⼤,所以只会进⾏关键部分的源码解析。
什么是公共注解?公共注解就是常见的Java 注解,特别是JSR-250中的注解。
例如:@Resource 、@PostConstructor 、@PreDestroy 等等,本⽂也就主要分析这三个注解在 Spring 中是如何处理的。
正⽂@Resource 注解的处理对 @Resource 注解的处理类是 CommonAnnotationBeanPostProcessor ,它通过实现 InstantiationAwareBeanPostProcessor 接⼝,重写postProcessProperties() ⽅法实现对标注了 @Resource 注解的字段或⽅法的⾃动注⼊。
InstantiationAwareBeanPostProcessor 接⼝的详细信息可以查看。
关于 CommonAnnotationBeanPostProcessor 这个后置处理器是怎么加⼊到 beanFactory 中的,我们在 ⼀⽂中介绍过主要是通过AnnotationConfigUtils#registerAnnotationConfigProcessors() 实现的。
BeanDefinition 合并后的后置处理CommonAnnotationBeanPostProcessor#postProcessMergedBeanDefinition上⾯代码中的 findAutowiringMetadata() ⽅法就是利⽤反射遍历类的所有字段和⽅法,找到标注了 @Resource 注解的,并缓存进injectionMetadataCache 中。
注意:静态字段和静态⽅法会过滤掉。
findAutowiringMetadata() ⽅法基本和 AutowiredAnnotationBeanPostProcessor 中的⼀致,只是处理的注解不同⽽已,可以查查看⼀⽂中该⽅法的详解。
springboot中使用自定义注解实现策略模式,去除工厂模式的switch或ifelse。。。
springboot中使⽤⾃定义注解实现策略模式,去除⼯⼚模式的switch或ifelse。
前⾔思路与模拟业务源码地址整体思路就是通过注解在策略类上指定约定好的type,项⽬启动之后将所有有注解的type获取到,根据type存储,然后在业务中根据type获取对应的策略即可模拟订单业务,根据订单的type,需要不同的处理逻辑,⽐如,免费订单,半价订单等,下⾯是项⽬结构:⼀策略接⼝和实现/*** 处理订单策略*/public interface OrderStrategy {void handleOrder(Order order);}@Component@HandlerOrderType(Order.FREE) //使⽤注解标明策略类型public class FreeOrderStrategy implements OrderStrategy {@Overridepublic void handleOrder(Order order) {System.out.println("----处理免费订单----");}}@Component@HandlerOrderType(Order.HALF)public class HalfOrderStrategy implements OrderStrategy {@Overridepublic void handleOrder(Order order) {System.out.println("----处理半价订单----");}}@Component@HandlerOrderType(Order.DISCOUT)public class DiscoutOrderStrategy implements OrderStrategy {@Overridepublic void handleOrder(Order order) {System.out.println("----处理打折订单----");}}⼆⾃定义策略注解@Target(ElementType.TYPE) //作⽤在类上@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited //⼦类可以继承此注解public @interface HandlerOrderType {/*** 策略类型* @return*/int value();}此处只能⽤基本类型或者String,约定的类型放在Order实体类⾥三业务实体public class Order {public static final int FREE=1; //免费订单public static final int HALF=2; //半价订单public static final int DISCOUT=3; //打折订单private String name;private Double price;private Integer type;//订单类型public static Order build(){return new Order();}四核⼼功能实现主要就是这⼀块实现策略逻辑/*** 根据订单类型返回对应的处理策略*/@Componentpublic class HandlerOrderContext {@Autowiredprivate ApplicationContext applicationContext;//存放所有策略类Bean的mappublic static Map<Integer, Class<OrderStrategy>> orderStrategyBeanMap= new HashMap<>();public OrderStrategy getOrderStrategy(Integer type){Class<OrderStrategy> strategyClass = orderStrategyBeanMap.get(type);if(strategyClass==null) throw new IllegalArgumentException("没有对应的订单类型");//从容器中获取对应的策略Beanreturn applicationContext.getBean(strategyClass);}}/*** 策略核⼼功能,获取所有策略注解的类型* 并将对应的class初始化到HandlerOrderContext中*/@Componentpublic class HandlerOrderProcessor implements ApplicationContextAware {/*** 获取所有的策略Beanclass 加⼊HandlerOrderContext属性中* @param applicationContext* @throws BeansException*/@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {//获取所有策略注解的BeanMap<String, Object> orderStrategyMap = applicationContext.getBeansWithAnnotation(HandlerOrderType.class); orderStrategyMap.forEach((k,v)->{Class<OrderStrategy> orderStrategyClass = (Class<OrderStrategy>) v.getClass();int type = orderStrategyClass.getAnnotation(HandlerOrderType.class).value();//将class加⼊map中,type作为keyHandlerOrderContext.orderStrategyBeanMap.put(type,orderStrategyClass);});}}五业务service使⽤@Componentpublic class OrderServiceImpl implements OrderService {@AutowiredHandlerOrderContext handlerOrderContext;@Overridepublic void handleOrder(Order order) {//使⽤策略处理订单OrderStrategy orderStrategy = handlerOrderContext.getOrderStrategy(order.getType());orderStrategy.handleOrder(order);}}很简单,业务代码以后基本不⽤再修改,不管添加多少策略或者需求变更多少次六 controller测试@RestController@RequestMapping("/order")public class OrderController {@AutowiredOrderService orderService;@GetMapping("/handler/{type}")public void handleOrder(@PathVariable Integer type){Order order = Order.build().add("name", "微信订单").add("price", 99.9).add("type", type);orderService.handleOrder(order);}}使⽤链式风格构造对象测试:再添加策略添加实现类,启⽤注解即可!省去了⼯⼚模式,直接⽤注解实现,避免修改⼯⼚类,这⾥贴⼀个我们之前项⽬的⼯⼚类实现:如果再添加策略还是会有轻微的改动!。
【SpringFramework】Spring入门教程(三)使用注解配置
【SpringFramework】Spring⼊门教程(三)使⽤注解配置本⽂主要介绍四个⽅⾯:(1) 注解版本IOC和DI(2) Spring纯注解(3) Spring测试(4) SpringJDBC - Spring对数据库的操作使⽤注解配置Spring⼊门说在前⾯学习基于注解的IoC配置,⼤家脑海⾥⾸先得有⼀个认知,即注解配置和xml配置要实现的功能都是⼀样的,都是要降低模块间的耦合度。
仅仅只是配置的形式不⼀样。
关于实际的开发中到底使⽤xml还是注解,每家公司有着不同的使⽤习惯。
所以这两种配置⽅式我们都需要掌握。
基于注解配置的⽅式也已经逐渐代替xml配置。
所以我们必须要掌握使⽤注解的⽅式配置Spring。
配置步骤注意:如果使⽤Eclipse需要先安装了STS插件,或者使⽤STS开发⼯具创建项⽬。
本⽂使⽤IDEA进⾏演⽰。
1.2.1. 第⼀步:拷贝必备jar包到⼯程的lib⽬录。
注意:在基于注解的配置中,我们还要多拷贝⼀个aop的jar包。
如下图:1.2.2. 第⼆步:在类的根路径下创建⼀个任意名称的xml⽂件(不能是中⽂)注意:基于注解整合时,Spring配置⽂件导⼊约束时需要多导⼊⼀个context命名空间下的约束。
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"></beans>1.2.3. 第⼆步:创建⼀个服务类创建⼀个测试的服务类,并且加⼊使⽤@Component注解,声明该类允许注⼊到Spring容器package org.cjw.service;import ponent;/*使⽤注解配置时,需要将Spring框架启动就创建对象的类表⽰为组件类表⽰组件类使⽤@Component注解*/@Componentpublic class CustomerService {public void save() {System.out.println("-保存数据-");}}1.2.4. 第四步在spring的配置⽂件加⼊扫描注解<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context/schema/context/spring-context.xsd"><!-- 声明扫描包及其⼦包的类,如果发现有组件注解的类,就创建对象并加⼊到容器中去 --><context:component-scan base-package="org.cjw" /></beans>1.2.5. 第五步:测试调⽤代码package org.cjw.test;import org.cjw.service.CustomerService;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class CustomerServiceTest {@Testpublic void testSave() {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");CustomerService customerService = context.getBean(CustomerService.class);customerService.save();}}--测试结果,如果可以调⽤服务⽅法,测试成功。
1.1SpringBoot环境配置和常用注解
1.1SpringBoot环境配置和常⽤注解Spring Boot常⽤注解:@Service: 注解在类上,表⽰这是⼀个业务层bean@Controller:注解在类上,表⽰这是⼀个控制层bean@Repository: 注解在类上,表⽰这是⼀个数据访问层bean@Component:注解在类上,表⽰通⽤bean ,value不写默认就是类名⾸字母⼩写@Autowired:按类型注⼊.默认属性required= true;当不能确定Spring 容器中⼀定拥有某个类的Bean 时,可以在需要⾃动注⼊该类Bean 的地⽅可以使⽤@Autowired(required = false),这等于告诉Spring:在找不到匹配Bean时也不抛出BeanCreationException 异常。
@Autowired 和 @Qualifier 结合使⽤时,⾃动注⼊的策略就从byType 转变byName 了。
@Autowired可以对成员变量、⽅法以及构造函数进⾏注释,⽽@Qualifier 的标注对象是成员变量、⽅法⼊参、构造函数⼊参。
正是由于注释对象的不同,所以 Spring 不将 @Autowired 和 @Qualifier 统⼀成⼀个注释类。
@Resource:按名称装配区别:@Resource默认按照名称⽅式进⾏bean匹配,@Autowired默认按照类型⽅式进⾏bean匹配@Resource(importjavax.annotation.Resource;)是J2EE的注解,@Autowired(importorg.springframework.beans.factory.annotation.Autowired;)是Spring的注解@Configuration:注解在类上,表⽰这是⼀个IOC容器,相当于spring的配置⽂件,java配置的⽅式。
IOC容器的配置类⼀般与@Bean 注解配合使⽤,⽤@Configuration 注解类等价与 XML 中配置 beans,⽤@Bean 注解⽅法等价于 XML 中配置 bean。
Spring常用的一些注解说明
Spring常⽤的⼀些注解说明@Configuration从Spring3.0,@Configuration⽤于定义配置类,可替换xml配置⽂件,被注解的类内部包含有⼀个或多个被@Bean注解的⽅法。
这些⽅法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进⾏扫描,并⽤于构建bean定义。
@Bean@Bean注解⽤于告诉⽅法,产⽣⼀个Bean对象,然后这个Bean对象交给Spring管理。
产⽣这个Bean对象的⽅法Spring只会调⽤⼀次,随后这个Spring将会将这个Bean对象放在⾃⼰的IOC容器中。
SpringIOC 容器管理⼀个或者多个bean,这些bean都需要在@Configuration注解下进⾏创建,在⼀个⽅法上使⽤@Bean注解就表明这个⽅法需要交给Spring进⾏管理。
@Autowired、@Resource@Resource和@Autowired注解都是⽤来实现依赖注⼊的。
只是@AutoWried按by type⾃动注⼊,⽽@Resource默认按byName⾃动注⼊。
♣ @Autowired@Autowired具有强契约特征,其所标注的属性或参数必须是可装配的。
如果没有Bean可以装配到@Autowired所标注的属性或参数中,⾃动装配就会失败,抛出NoSuchBeanDefinitionException.@Autowired可以对类成员变量、⽅法及构造函数进⾏标注,让 spring 完成 bean ⾃动装配的⼯作。
@Autowired 默认是按照类去匹配,配合 @Qualifier 指定按照名称去装配 bean。
♣ @Resource@Resource是JDK提供的注解,有两个重要属性,分别是name和type。
@Resource依赖注⼊时查找bean的规则既不指定name属性,也不指定type属性,则⾃动按byName⽅式进⾏查找。
SpringBoot事务注解详解
SpringBoot事务注解详解SpringBoot事务注解详解@Transactionalspring 事务注解1.简单开启事务管理@EnableTransactionManagement // 启注解事务管理,等同于xml配置⽅式的 <tx:annotation-driven />2.事务注解详解默认遇到throw new RuntimeException(“…”);会回滚需要捕获的throw new Exception(“…”);不会回滚指定回滚@Transactional(rollbackFor=Exception.class)public void methodName() {// 不会回滚throw new Exception("...");}指定不回滚@Transactional(noRollbackFor=Exception.class)public ItimDaoImpl getItemDaoImpl() {// 会回滚throw new RuntimeException("注释");}如果有事务,那么加⼊事务,没有的话新建⼀个(不写的情况下)@Transactional(propagation=Propagation.REQUIRED)容器不为这个⽅法开启事务@Transactional(propagation=Propagation.NOT_SUPPORTED)readOnly=true只读,不能更新,删除@Transactional (propagation = Propagation.REQUIRED,readOnly=true)设置超时时间@Transactional (propagation = Propagation.REQUIRED,timeout=30)设置数据库隔离级别@Transactional (propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT)3.指定事务管理器spring Boot 使⽤事务⾮常简单,⾸先使⽤注解 @EnableTransactionManagement 开启事务⽀持后,然后在访问数据库的Service⽅法上添加注解 @Transactional 便可。
使用spring的@Scheduled注解执行定时任务,启动项目不输出警告
使⽤spring的@Scheduled注解执⾏定时任务,启动项⽬不输出警告在applicationContext.xml中添加:xmlns:task="/schema/task"xsi:schemaLocation="/schema/task/schema/task/spring-task-4.0.xsd"><task:annotation-driven executor="myExecutor" scheduler="myScheduler"/><task:executor id="myExecutor" pool-size="5"/><task:scheduler id="myScheduler" pool-size="10"/>java代码:@Componentpublic class CleanExpireTokenTask {private Logger logger = LoggerFactory.getLogger(LogTag.BUSINESS);@Scheduled(cron = "0 * * * * ?")public void startUpdateSaleThread(){try{System.out.println("check token expire");}catch(Exception e){logger.error("Make salesReport faild",e);}}}注意:实现类上要加注解@Component定时器的任务⽅法不能有返回值配置及启动报错问题参考⾃2016-11-22⽇安全关闭spring定时任务线程池java代码@Resource(name = "myScheduler")private ThreadPoolTaskScheduler threadPoolTaskScheduler;/*** 等待正在执⾏的定时任务执⾏完毕,不再执⾏新的定时任务,*/public void shutdown(){ threadPoolTaskScheduler.shutdown(); // 等待任务执⾏完毕 while(threadPoolTaskScheduler.getActiveCount() > 0){ try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } }}注:1.根据测试,通过此⽅式创建的定时任务,⽐如每分钟0秒执⾏任务,如果上⼀分钟0秒执⾏的任务还没执⾏完,则这次任务就不会启动。
Spring声明式事务注解之@EnableTransactionManagement解析
Spring声明式事务注解之@EnableTransactionManagement解析Spring声明式事务注解之@EnableTransactionManagement1. 说明@EnableTransactionManagement声明在主配置类上,表⽰开启声明式事务,其原理是通过@Import导⼊TransactionManagementConfigurationSelector组件,然后⼜通过TransactionManagementConfigurationSelector导⼊组件AutoProxyRegistrar和ProxyTransactionManagementConfiguration;2. 原理分析@EnableTransactionManagement代码实现如下:@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented// 通过@Import导⼊TransactionManagementConfigurationSelector组件@Import(TransactionManagementConfigurationSelector.class)public @interface EnableTransactionManagement {boolean proxyTargetClass() default false;AdviceMode mode() default AdviceMode.PROXY;int order() default Ordered.LOWEST_PRECEDENCE;}@EnableTransactionManagement通过@Import导⼊TransactionManagementConfigurationSelector;TransactionManagementConfigurationSelector的实现如下:public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {/*** {@inheritDoc}* @return {@link ProxyTransactionManagementConfiguration} or* {@code AspectJTransactionManagementConfiguration} for {@code PROXY} and* {@code ASPECTJ} values of {@link EnableTransactionManagement#mode()}, respectively*/@Overrideprotected String[] selectImports(AdviceMode adviceMode) {switch (adviceMode) {case PROXY:// 根据@EnableTransactionManagement的固定值PROXY,这⾥会导⼊AutoProxyRegistrar组件和ProxyTransactionManagementConfiguration组件 return new String[] {AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};case ASPECTJ:return new String[] {TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME};default:return null;}}}所以TransactionManagementConfigurationSelector⼜导⼊了组件AutoProxyRegistrar和ProxyTransactionManagementConfiguration;3. AutoProxyRegistrar分析3.1 AutoProxyRegistrar继承关系InfrastructureAdvisorAutoProxyCreator--AbstractAdvisorAutoProxyCreator--AbstractAdvisorAutoProxyCreator--ProxyProcessorSupport--SmartInstantiationAwareBeanPostProcessor // 跟AOP是原理是⼀样的--InstantiationAwareBeanPostProcessor--BeanPostProcessor--BeanFactoryAware3.2 AutoProxyRegistrar的所⽤AutoProxyRegistrar的作⽤跟AOP中的AnnotationAwareAspectJAutoProxyCreator是⼀样的,利⽤后置处理器机制在对象创建以后,包装对象,返回⼀个代理对象(增强器),代理对象执⾏⽅法利⽤拦截器链进⾏调⽤;InfrastructureAdvisorAutoProxyCreator继承SmartInstantiationAwareBeanPostProcessor,跟AOP的原理是⼀样的,也是通过@Transactional作为⽅法拦截的标记,把有事务管理的类作为⽬标类,⽣成代理对象,然后增强@Transactional标记的⽅法,在使⽤⽬标⽅法的时候,从IOC容器中获取的其实是被增强的代理类,且事务⽅法会被代理,跟AOP原理⼀样的;4. ProxyTransactionManagementConfiguration分析ProxyTransactionManagementConfiguration是⼀个配置类,想IOC容器中导⼊事务增强器(BeanFactoryTransactionAttributeSourceAdvisor),事务注解@Transactional的解析器(AnnotationTransactionAttributeSource)和事务⽅法拦截器(TransactionInterceptor);package org.springframework.transaction.annotation;import org.springframework.beans.factory.config.BeanDefinition;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.Role;import org.springframework.transaction.config.TransactionManagementConfigUtils;import org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor;import org.springframework.transaction.interceptor.TransactionAttributeSource;import org.springframework.transaction.interceptor.TransactionInterceptor;@Configurationpublic class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {/**事务增强器(Advisor),在事务类创建的时候,被AutoProxyRegistrar导⼊的组件InfrastructureAdvisorAutoProxyCreator拦截,InfrastructureAdvisorAutoProxyCreator拦截的逻就是增强事务类的事务⽅法,⽽BeanFactoryTransactionAttributeSourceAdvisor作为增强器,与需要增强的⽅法(这⾥是指被@Transactional标记的⽅法)进⾏匹配,匹配成功的增强器,最后转成拦截器(MethodInterceptor,就是下⾯的TransactionInterceptor),然后与⽬标⽅法⼀起在拦截器链中被执⾏,达到⽅法增强的效果;BeanFactoryTransactionAttributeSourceAdvisor的继承关系如下:BeanFactoryTransactionAttributeSourceAdvisor--AbstractBeanFactoryPointcutAdvisor--AbstractPointcutAdvisor--PointcutAdvisor--AdvisorAOP中AspectJPointcutAdvisor的继承关系如下,与AbstractPointcutAdvisor⼀样,都实现PointcutAdvisor--AspectJPointcutAdvisor--PointcutAdvisor--Advisor*/@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();advisor.setTransactionAttributeSource(transactionAttributeSource());advisor.setAdvice(transactionInterceptor());advisor.setOrder(this.enableTx.<Integer>getNumber("order"));return advisor;}/**@Transactional注解的解析类;负责解析事务⽅法上@Transactional中的各个参数配置,解析的时机是在创建事务类之后被增强的时候,匹配事务⽅法的时候⼀起被解析了AnnotationTransactionAttributeSource的继承关系如下:AnnotationTransactionAttributeSource--AbstractFallbackTransactionAttributeSource--TransactionAttributeSource通过⽅法org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource.getTransactionAttribute(Method, Class<?>)解析出事务信息TransactionAttribute;AnnotationTransactionAttributeSource在⽅法findTransactionAttribute(Class<?>)中依赖于SpringTransactionAnnotationParser在解析事务类时,绑定事务⽅法与增强器的时候进⾏@Transactional注解解析;*/@Bean@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public TransactionAttributeSource transactionAttributeSource() {return new AnnotationTransactionAttributeSource();}/**被@Transactional标记的事务⽅法的拦截器,实际是⼀个MethodInterceptor保存了事务属性信息,事务管理器;在⽬标⽅法执⾏的时候;执⾏拦截器链;*/@Bean@Role(BeanDefinition.ROLE_INFRASTRUCTURE)public TransactionInterceptor transactionInterceptor() {TransactionInterceptor interceptor = new TransactionInterceptor();interceptor.setTransactionAttributeSource(transactionAttributeSource());if (this.txManager != null) {interceptor.setTransactionManager(this.txManager);}return interceptor;}}在SpringTransactionAnnotationParser中parseTransactionAnnotation⽅法来解析@Transactional中的各个参数,其具体代码如下:protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();Propagation propagation = attributes.getEnum("propagation");rbta.setPropagationBehavior(propagation.value());Isolation isolation = attributes.getEnum("isolation");rbta.setIsolationLevel(isolation.value());rbta.setTimeout(attributes.getNumber("timeout").intValue());rbta.setReadOnly(attributes.getBoolean("readOnly"));rbta.setQualifier(attributes.getString("value"));ArrayList<RollbackRuleAttribute> rollBackRules = new ArrayList<RollbackRuleAttribute>();Class<?>[] rbf = attributes.getClassArray("rollbackFor");for (Class<?> rbRule : rbf) {RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);rollBackRules.add(rule);}String[] rbfc = attributes.getStringArray("rollbackForClassName");for (String rbRule : rbfc) {RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);rollBackRules.add(rule);}Class<?>[] nrbf = attributes.getClassArray("noRollbackFor");for (Class<?> rbRule : nrbf) {NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);rollBackRules.add(rule);}String[] nrbfc = attributes.getStringArray("noRollbackForClassName");for (String rbRule : nrbfc) {NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);rollBackRules.add(rule);}rbta.getRollbackRules().addAll(rollBackRules);return rbta;}spring 事务 @EnableTransactionManagement原理@EnableXXX原理:注解上有个XXXRegistrar,或通过XXXSelector引⼊XXXRegistrar,XXXRegistrar实现了ImportBeanDefinitionRegistrar的registerBeanDefinitions⽅法,给容器注册XXXCreator。
Spring中如何使用自定义注解搭配@Import引入内外部配置并完成某一功能的启用
Spring中如何使⽤⾃定义注解搭配@Import引⼊内外部配置并完成某⼀功能的启⽤有些⽹站第⼀时间爬取了我的原创⽂章,并且没有注明出处,不得已在这⾥加上说明。
⽂章背景有⼀个封装 RocketMq 的 client 的需求,⽤来提供给各项⽬收、发消息,但是项⽬当中常常只使⽤收或者发消息的单⼀功能,⽽且不同的项⽬group等并不相同⽽且不会变化,可以在项⽬当中配置,其余的topic等配置信息因有变动则迁移到配置中⼼去,因此萌⽣了如下想法提供⼀个⾃定义注解来启⽤收、发消息其中之⼀或者全部的公共组件研究之后,决定采⽤@Import来实现该功能⼀、Java注解的简单介绍注解,也叫Annotation、标注,是 Java 5 带来的新特性。
1. 可使⽤范围类、字段、⽅法、参数、构造函数、包等,具体可参阅枚举类ng.annotation.ElementType2. ⽣命周期(摘⾃)RetentionPolicy.SOURCE注解只保留在源⽂件,当Java⽂件编译成class⽂件的时候,注解被遗弃RetentionPolicy.CLASS注解被保留到class⽂件,但 jvm 加载class⽂件时候被遗弃,这是默认的⽣命周期RetentionPolicy.RUNTIME注解不仅被保存到class⽂件中,jvm 加载class⽂件之后,仍然存在3. 使⽤⽅式可以使⽤反射获取注解的内容,具体如何使⽤请⾃⼰百度,可参考这篇,这⾥不是重点,不多做介绍⼆、Spring的@Import注解@Import注解是Spring⽤来注⼊ Spring Bean 的⼀种⽅式,可以⽤来修饰别的注解,也可以直接在Springboot配置类上使⽤。
它只有⼀个value属性需要设置,来看⼀下源码public @interface Import {Class<?>[] value();}这⾥的 value属性只接受三种类型的Class:被@Configuration修饰的配置类接⼝org.springframework.context.annotation.ImportBeanDefinitionRegistrar的实现类接⼝org.springframework.context.annotation.ImportSelector的实现类下⾯针对三种类型的 Class 分别做简单介绍,⽂章后⾯有⾃定义注解与外部配置的结合使⽤⽅式。
Spring核心注解
Spring注解使⽤场景启始版本模式注解@Repository数据仓储模式注解Spring Framework 2.0 @Component通⽤组件模式注解Spring Framework 2.5 @Service服务模式注解Spring Framework 2.5 @Controller Web控制器模式注解Spring Framework 2.5 @Configuration配置类模式注解Spring Framework 3.0装配注解@ImportResource替换XML元素<import>Spring Framework 2.5 @Import限定@Autowired依赖注⼊范围(导⼊对应的 @Configuration 标识类)Spring Framework 3.0 @ComponentScan扫描制定package下标注Spring模式注解的类Spring Framework 3.1依赖注⼊注解@Autowired Bean依赖注⼊,⽀持多种依赖查找⽅式Spring Framework 2.5 @Qualifier细粒度的@Autowired依赖查找⽅式Spring Framework 2.5 @Resource [JAVA注解]Bean依赖注⼊,仅⽀持名称依赖查找⽅式Spring Framework 2.5 Bean定义注解@Bean替换XML元素<bean/>Spring Framework 3.0 @DependsOn替换XML属性<bean depends-on="..."/>Spring Framework 3.0 @Lazy替代XML属性<bean lazy-init="true|false"/>Spring Framework 3.0 @Primary替换XML属性<bean primary="true|false"/>Spring Framework 3.0 @Role替换XML属性<bean role="..."/>Spring Framework 3.1 @Lookup替代XML属性<bean lookup-method="..."/>Spring Framework 4.1条件装配注解@Profile配置化条件装配Spring Framework 3.1 @Conditional编程条件装配Spring Framework 4.0配置属性注解@PropertySource配置属性抽象PropertySource注解Spring Framework 3.1 @PropertySources@PropertySource集合注解(实现 JAVA 8 @Repeatable相似的功能)Spring Framework 4.0⽣命周期回调注解@PostConstruct替换XML元素<bean init-method="..."/>或InitializingBean Spring Framework 2.5 @PreDestory替换XML元素<bean destory-method="..."/>或 DisposableBean Spring Framework 2.5注解属性注解@AliasFor别名注解属性,实现复⽤的⽬的Spring Framework 4.2性能注解@Indexed提升Spring模式注解的扫描效率(编译时会在classPath下⽣成 META-INF/ponents⽂件)Spring Framework 5.0Spring核⼼注解Spring核⼼注解归类如下:。
Spring中Bean管理的常用注解
Spring中Bean管理的常⽤注解在Spring中,主要⽤于管理bean的注解分为四⼤类:1.⽤于创建对象。
2.⽤于给对象的属性注⼊值。
3.⽤于改变作⽤的范围。
4.⽤于定义⽣命周期。
这⼏个在开发中经常接触到,也可以说每天都会遇见。
其中创建对象是重点,Spring中创建对象的有四个:分别是@Component,@Controller,@Service,@Repository。
对于@Component注解:把资源让Spring来管理,相当于xml中的配置的Bean。
属性:value:指定Bean中的id。
如果不指定value属性,默认Bean的id是当前类的类名,⾸字母⼩写。
在开发中的场景是这样的,其实是在实现类中加⼊即可:@Component("customerService")public class CustomerServiceImpl implements CustomerService{public void save() {System.out.println("顾客保存⽅法");}}⽽其它的三个注解都是针对⼀个衍⽣注解,它们的作⽤及属性都是⼀模⼀样的。
只不过提供了更加明确的语义化。
@Controller:⼀般⽤于表现层的注解。
@Service:⼀般⽤于业务层的注解。
@responsitory:⼀般⽤于持久层的注解。
⽤法与以上相同,这⾥不做过多的解释。
要理解这个三个注解就是让标注类本⾝的⽤途清晰⽽已。
接下来,聊聊⽤于给对象的属性注⼊值得问题。
Spring给我们提出了注⼊数据的注解有:@Value,@Autowired,@Qualifier,@Resource。
其中@Value:注⼊基本数据类型和String类型数据,它的属性value⽤于指定值。
@Autowired这个⽤法是⽐较重要的,它能够⾃动按照类型注⼊。
当使⽤注解注⼊属性时,set⽅法可以省略。
Spring缓存注解SpEL表达式解析
Spring缓存注解SpEL表达式解析缓存注解上 key、condition、unless 等 SpEL 表达式的解析SpEl ⽀持的计算变量:1)#ai、#pi、#命名参数【i 表⽰参数下标,从 0 开始】2)#result:CachePut 操作和后处理 CacheEvict 操作都可使⽤3)#root:CacheExpressionRootObject 对象计算上下⽂根对象/*** 缓存注解 SpEL 表达式计算上下⽂根对象*/class CacheExpressionRootObject {/*** 有效的缓存集合*/private final Collection<? extends Cache> caches;/*** ⽬标⽅法*/private final Method method;/*** ⽅法参数*/private final Object[] args;/*** ⽬标对象*/private final Object target;/*** ⽬标对象 Class 类型*/private final Class<?> targetClass;}缓存计算上下⽂【附加⽅法参数和返回结果作为计算变量】/*** 基于⽅法的表达式计算上下⽂* @since 4.2*/public class MethodBasedEvaluationContext extends StandardEvaluationContext {/*** ⽬标⽅法*/private final Method method;/*** 参数数组*/private final Object[] arguments;/*** 参数名发现者*/private final ParameterNameDiscoverer parameterNameDiscoverer;/*** 参数变量是否已经加载*/private boolean argumentsLoaded = false;public MethodBasedEvaluationContext(Object rootObject, Method method, Object[] arguments,ParameterNameDiscoverer parameterNameDiscoverer) {super(rootObject);this.method = method;this.arguments = arguments;this.parameterNameDiscoverer = parameterNameDiscoverer;}@Override@Nullablepublic Object lookupVariable(String name) {// 1)尝试从变量映射中读取指定名称的对象Object variable = super.lookupVariable(name);if (variable != null) {return variable;}// 2)未读到 && ⽅法参数未加载if (!this.argumentsLoaded) {// 加载⽅法参数lazyLoadArguments();this.argumentsLoaded = true;// 再次读取variable = super.lookupVariable(name);}return variable;}protected void lazyLoadArguments() {// ⽆参数则直接退出if (ObjectUtils.isEmpty(this.arguments)) {return;}// 读取⽬标⽅法的所有参数名称String[] paramNames = this.parameterNameDiscoverer.getParameterNames(this.method);// 计算形参个数,以解析到的参数名优先【可能存在可变参数】int paramCount = (paramNames != null ? paramNames.length : this.method.getParameterCount()); // 实际传⼊的参数个数int argsCount = this.arguments.length;for (int i = 0; i < paramCount; i++) {Object value = null;/*** 实际传⼊的参数个数 > 形参个数* && 将余下的所有⼊参都加⼊到数组中【⽬标⽅法最后⼀个参数是可变参数】*/if (argsCount > paramCount && i == paramCount - 1) {value = Arrays.copyOfRange(this.arguments, i, argsCount);}// 读取实际参数else if (argsCount > i) {// Actual argument found - otherwise left as nullvalue = this.arguments[i];}/*** 将 ai、pi、实际参数名称作为键,加⼊到计算变量映射中* a0、p0 都表⽰第⼀个参数,依次类推*/setVariable("a" + i, value);setVariable("p" + i, value);if (paramNames != null) {setVariable(paramNames[i], value);}}}}/*** 缓存计算上下⽂,⾃动将⽅法参数添加为计算变量。
SpringBoot注解解析大全(非常全哦!)
SpringBoot注解解析⼤全(⾮常全哦!)使⽤注解的优势:1.采⽤纯java代码,不在需要配置繁杂的xml⽂件2.在配置中也可享受⾯向对象带来的好处3.类型安全对重构可以提供良好的⽀持4.减少复杂配置⽂件的同时亦能享受到springIoC容器提供的功能⼀、注解详解(配备了完善的释义)------(可采⽤ctrl+F 来进⾏搜索哦~~~~也可以收藏⽹页这样以后就不⽤往复查询了哦)@SpringBootApplication:申明让spring boot⾃动给程序进⾏必要的配置,这个配置等同于:@Configuration ,@EnableAutoConfiguration 和 @ComponentScan 三个配置。
@ResponseBody:表⽰该⽅法的返回结果直接写⼊HTTP response body中,⼀般在异步获取数据时使⽤,⽤于构建RESTful的api。
在使⽤@RequestMapping后,返回值通常解析为跳转路径,加上@esponsebody后返回结果不会被解析为跳转路径,⽽是直接写⼊HTTP response body中。
⽐如异步获取json数据,加上@Responsebody后,会直接返回json数据。
该注解⼀般会配合@RequestMapping⼀起使⽤。
@Controller:⽤于定义控制器类,在spring项⽬中由控制器负责将⽤户发来的URL请求转发到对应的服务接⼝(service层),⼀般这个注解在类中,通常⽅法需要配合注解@RequestMapping。
@RestController:⽤于标注控制层组件(如struts中的action),@ResponseBody和@Controller的合集。
@RequestMapping:提供路由信息,负责URL到Controller中的具体函数的映射。
@EnableAutoConfiguration:SpringBoot⾃动配置(auto-configuration):尝试根据你添加的jar依赖⾃动配置你的Spring应⽤。
SpringBoot中常用注解及各种注解作用
SpringBoot中常⽤注解及各种注解作⽤本篇⽂章将介绍⼏种SpringBoot 中常⽤注解其中,各注解的作⽤为:@PathVaribale 获取url中的数据@RequestParam 获取请求参数的值@GetMapping 组合注解,是@RequestMapping(method = RequestMethod.GET)的缩写@RestController是@ResponseBody和@Controller的组合注解。
@PathVaribale 获取url中的数据看⼀个例⼦,如果我们需要获取Url=localhost:8080/hello/id中的id值,实现代码如下:@RestControllerpublic class HelloController {@RequestMapping(value="/hello/{id}",method= RequestMethod.GET)public String sayHello(@PathVariable("id") Integer id){return "id:"+id;}}@RequestParam 获取请求参数的值直接看⼀个例⼦,如下@RestControllerpublic class HelloController {@RequestMapping(value="/hello",method= RequestMethod.GET)public String sayHello(@RequestParam("id") Integer id){return "id:"+id;}}在浏览器中输⼊地址:localhost:8080/hello?id=1000,可以看到如下的结果:当我们在浏览器中输⼊地址:localhost:8080/hello?id ,即不输⼊id的具体值,此时返回的结果为null。
string boot的常用注解
string boot的常用注解Spring Boot是一个基于Spring框架的开发框架,致力于简化Java应用程序的开发过程。
它通过使用注解来简化配置,并提供了许多实用的注解来增强开发者的生产力和开发效率。
下面将介绍一些常用的Spring Boot注解。
1. @SpringBootApplication:这是一个组合注解,包含了@Configuration、@EnableAutoConfiguration和 @ComponentScan等注解,用于指定Spring Boot应用程序的入口类。
2. @Controller:标识一个类为控制器,处理用户的HTTP请求。
3. @RestController:与@Controller注解类似,但是更适合用于构建RESTful Web服务,常用于构建后端接口。
4. @RequestMapping:用于映射URL和方法的关系。
可以使用@GetMapping、@PostMapping、@PutMapping等注解指定HTTP请求方法。
5. @Autowired:用于自动注入依赖项,可用于构造函数、字段、方法以及配置类中。
6. @Service:标记一个类为服务类,充当业务逻辑层。
7. @Repository:标记一个类为持久层类,用于访问数据库或其他持久化存储。
8. @Configuration:标记一个类为配置类,通常包含@Bean注解用于创建和初始化Bean。
9. @Bean:用于定义一个Bean对象,该对象会被Spring容器管理。
10. @Value:用于注入属性值,可以用于类的字段或者方法参数上。
11. @Component:泛指Spring管理的组件,作为抽象注解,通常与其它注解组合使用,如@Service和@Repository。
12. @ConditionalOnProperty:在满足指定条件的情况下激活配置项,主要用于控制配置文件中的属性。
Spring的注解详解
Spring的注解一、 spring注解1、@Autowired注入注解@Autowired可以对成员变量、方法和构造函数进行标注,来完成自动装工作。
@Autowired的标注位置不同,它们都会在Spring在初始化这个bean时,自动装配这个属性。
@Autowired是根据类型进行自动装配的。
例如,如果当Spring上下文中存在不止一个UserDao类型的bean时,就会抛出BeanCreationException异常。
如果Spring上下文中不存在UserDao类型的bean,也会抛出BeanCreationException异常。
我们可以使用@Qualifier配合@Autowired来解决这些问题。
1.public class TestController {2.3.@Autowired4.@Qualifier(“u serDao”)5.Private UserService userService;6.7.@RequestMapping("/showView")8.public ModelAndView showView(){9.ModelAndView modelAndView = new ModelAndView();10.modelAndView.setViewName("viewName");11.modelAndView.addObject("属性名称","属性值");12.return modelAndView;13.}14.}2、@Resource注入注解JSR-250标准注解,推荐使用它来代替Spring专有的@Autowired注解。
@Resource的作用相当于@Autowired,只不过@Autowired按byType自动注入,而@Resource 默认按byName自动注入罢了。
SpringBoot常用注解和原理整理
SpringBoot常⽤注解和原理整理⼀、启动注解 @SpringBootApplication@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited@SpringBootConfiguration@EnableAutoConfiguration@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })public @interface SpringBootApplication {}查看源码可发现,@SpringBootApplication是⼀个复合注解,包含了@SpringBootConfiguration,@EnableAutoConfiguration`,@ComponentScan`这三个注解``@SpringBootConfiguration注解,继承@Configuration注解,主要⽤于加载配置⽂件@SpringBootConfiguration继承⾃@Configuration`,⼆者功能也⼀致,标注当前类是配置类,并会将当前类内声明的⼀个或多个以@Bean注解标记的⽅法的实例纳⼊到spring容器中,并且实例名就是⽅法名。
@EnableAutoConfiguration 注解,开启⾃动配置功能@EnableAutoConfiguration可以帮助SpringBoot应⽤将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使⽤的IoC容器。
springMVC详解以及注解说明
springMVC详解以及注解说明基于注释(Annotation)的配置有越来越流行的趋势,Spring 2.5 顺应这种趋势,提供了完全基于注释配置Bean、装配Bean 的功能,您可以使用基于注释的Spring IoC 替换原来基于XML 的配置。
本文通过实例详细讲述了Spring 2.5 基于注释IoC 功能的使用。
概述注释配置相对于XML 配置具有很多的优势:∙ 它可以充分利用Java 的反射机制获取类结构信息,这些信息可以有效减少配置的工作。
如使用JPA 注释配置ORM 映射时,我们就不需要指定PO 的属性名、类型等信息,如果关系表字段和PO 属性名、类型都一致,您甚至无需编写任务属性映射信息——因为这些信息都可以通过Java 反射机制获取。
∙ 注释和Java 代码位于一个文件中,而XML 配置采用独立的配置文件,大多数配置信息在程序开发完成后都不会调整,如果配置信息和Java 代码放在一起,有助于增强程序的内聚性。
而采用独立的XML 配置文件,程序员在编写一个功能时,往往需要在程序文件和配置文件中不停切换,这种思维上的不连贯会降低开发效率。
因此在很多情况下,注释配置比XML 配置更受欢迎,注释配置有进一步流行的趋势。
Spring 2.5 的一大增强就是引入了很多注释类,现在您已经可以使用注释配置完成大部分XML 配置的功能。
在这篇文章里,我们将向您讲述使用注释进行Bean 定义和依赖注入的内容。
Spring2.5的注释Spring 2.5 提供了AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、PersistenceAnnotationBeanPostProcessor 和RequiredAnnotationBeanPostProcessor这四个主要的关于Annotation 的BeanPostProcessor。
详解springmvc常用5种注解
详解springmvc常⽤5种注解⼀、组件型注解:1、@Component 在类定义之前添加@Component注解,他会被spring容器识别,并转为bean。
2、@Repository 对Dao实现类进⾏注解 (特殊的@Component)3、@Service ⽤于对业务逻辑层进⾏注解, (特殊的@Component)4、@Controller ⽤于控制层注解, (特殊的@Component)以上四种注解都是注解在类上的,被注解的类将被spring初始话为⼀个bean,然后统⼀管理。
⼆、请求和参数型注解:1、@RequestMapping:⽤于处理请求地址映射,可以作⽤于类和⽅法上。
●value:定义request请求的映射地址●method:定义地request址请求的⽅式,包括【GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE.】默认接受get请求,如果请求⽅式和定义的⽅式不⼀样则请求⽆法成功。
●params:定义request请求中必须包含的参数值。
●headers:定义request请求中必须包含某些指定的请求头,如:RequestMapping(value = "/something", headers = "content-type=text/*")说明请求中必须要包含"text/html", "text/plain"这中类型的Content-type头,才是⼀个匹配的请求。
●consumes:定义请求提交内容的类型。
●produces:指定返回的内容类型,仅当request请求头中的(Accept)类型中包含该指定类型才返回@RequestMapping(value="/requestTest.do",params = {"name=sdf"},headers = {"Accept-Encoding=gzip, deflate, br"},method = RequestMethod.GET) public String getIndex(){System.out.println("请求成功");return "index";}上⾯代码表⽰请求的⽅式为GET请求,请求参数必须包含name=sdf这⼀参数,然后请求头中必须有 Accept-Encoding=gzip, deflate, br这个类型头。
Spring系列之Spring常用注解总结
Spring系列之Spring常⽤注解总结Spring系列之Spring常⽤注解总结传统的Spring做法是使⽤.xml⽂件来对bean进⾏注⼊或者是配置aop、事物,这么做有两个缺点:1、如果所有的内容都配置在.xml⽂件中,那么.xml⽂件将会⼗分庞⼤;如果按需求分开.xml⽂件,那么.xml⽂件⼜会⾮常多。
总之这将导致配置⽂件的可读性与可维护性变得很低。
2、在开发中在.java⽂件和.xml⽂件之间不断切换,是⼀件⿇烦的事,同时这种思维上的不连贯也会降低开发的效率。
为了解决这两个问题,Spring引⼊了注解,通过"@XXX"的⽅式,让注解与Java Bean紧密结合,既⼤⼤减少了配置⽂件的体积,⼜增加了Java Bean的可读性与内聚性。
不使⽤注解:先看⼀个不使⽤注解的Spring⽰例,在这个⽰例的基础上,改成注解版本的,这样也能看出使⽤与不使⽤注解之间的区别,先定义⼀个⽼虎:package com.spring.model;public class Tiger {private String tigerName="TigerKing";public String toString(){return "TigerName:"+tigerName;}}再定义⼀个猴⼦:package com.spring.model;public class Monkey {private String monkeyName = "MonkeyKing";public String toString(){return "MonkeyName:" + monkeyName;}}定义⼀个动物园:package com.spring.model;public class Zoo {private Tiger tiger;private Monkey monkey;public Tiger getTiger() {return tiger;}public void setTiger(Tiger tiger) {this.tiger = tiger;}public Monkey getMonkey() {return monkey;}public void setMonkey(Monkey monkey) {this.monkey = monkey;}public String toString(){return tiger + "\n" + monkey;}}spring的配置⽂件这么写:<?xml version="1.0" encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"><bean id="zoo" class="com.spring.model.Zoo"><property name="tiger" ref="tiger"/><property name="monkey" ref="monkey"/></bean><bean id="tiger" class="com.spring.model.Tiger"/><bean id="monkey" class="com.spring.model.Monkey"/></beans>测试⽅法:public class TestAnnotation {/*** 不使⽤注解*/@Testpublic void test(){//读取配置⽂件ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext2.xml");Zoo zoo=(Zoo) ctx.getBean("zoo");System.out.println(zoo.toString());}}都很熟悉,权当复习⼀遍了。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1声明bean
1.1实例
有类:
public class MyBean{
//do something
}
xml 方式:
<bean id="myBean"class="com.bean.MyBean"/>
//通过 @Autowired 注解注入 SysUserLoginDao 依赖
@Autowired
private UserDao userDao;
//省略
}
public class UserAction {
@Autowired
<propertyname="myBean" ref="myBean"/>
</bean>
注解方式:
@Component("myBean")
public class MyBean {
//do something
}
@Component("myBean2")
注解方式:
@Component("myBean")
public class MyBean {
//do something
}
1.2说明
除了使用 @Component 注解,还可以使用 @Controller, @Service, @Repository 。一般情况下 service 使用 @Service ,dao 使用 @Repository ,其他的使用 @Component(@Controller 一般在使用 spring mvc 的时候使用)。
a)属性注入
@Component
public class MyBean2 {
@ Autowired
private MyBeanmyBean;
}
b)方法注入
@Component
public class MyBean2 {
private MyBean myBean;
public class MyBean2 {
@Autowired
private MyBean myBean;
//do someting
}
2.2说明
注入bean 可以使用以下注解
@Resource, @Autowired, @Inject
2.2.1注入方式
}
/*************************性感的分隔线**************************/
public interface UserService {
}
@Service
@Scope("prototype")
public classUserServiceImpl implements UserService {
@ Autowired
private voidsetMyBean (MyBean myBean){
this.m构造方法注入
@Component
public class MyBean2 {
private MyBean myBean;
}
public class MyBean2 {
private MyBean myBean;
//do someting
}
xml 方式:
<bean id="myBean" class="com.bean.MyBean"/>
<bean id="myBean2"class="com.bean.MyBean2">
@ Autowired
public MyBean2(MyBean myBean){
this.myBean = myBean;
}
}
3.其他
依赖注入的层次最好符合这样的约束:action 使用 service ;service 使用 dao.
3.1注解使用示例
注解方式:
@Component("myBean")
@Scope("prototype")
public class MyBean {
}
2.注入bean
2.1实例
将 myBean 注入到 myBean2
有类:
public class MyBean{
//do something
privateUserService userService;
public Stringexecute(){
//do something
}
}
public interface UserDao {
}
//通过 @Compoent 声明 spring bean,@Repository
@Scope("prototype")
public class UserDaoImpl implements UserDao {
//省略...
1.2.1配置scope (生命周期)
spring 默认为 "singleton" 单例,没有特别原因建议使用"prototype"
xml 方式:
<bean id="myBean" class="com.bean.MyBean" scope="prototype"/>