Spring4 Bean管理的注解实现

最新推荐文章于 2024-07-16 08:45:00 发布
最新推荐文章于 2024-07-16 08:45:00 发布
阅读量2.5k 收藏
点赞数
分类专栏： Maven学习总结_old Spring学习总结_old
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu631464569/article/details/51924153
版权

日期： 2016-7-16


内容： 学习Spring Bean管理的注解实现；



主要内容：

1、ClassPath扫描与组件管理；


2、类的自动检测与注册Bean；

Spring可以自动检测类并注册Bean到ApplicationContext中

@Service
public class SimpleMovieLister{
    private MovieFinder movieFinder;

    @Autowired
    publicc SimpleMovieLister(MovieFinder movieFinder)
{
    this.movieFinder = movieFinder;
}

}


3、<context:annotation-config/>;

通过在基于XML的Spring陪住如下标签(请添加上下文的命名空间)；

<context:annotation-config/>仅会查找在同一个applicationContext中的bean注解。

<?xml version="1.0" encoding="UTF-8"?>    
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"    
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util" xmlns:jdbc="http://www.springframework.org/schema/jdbc"    
    xmlns:cache="http://www.springframework.org/schema/cache"    
    xsi:schemaLocation="    
    http://www.springframework.org/schema/context    
    http://www.springframework.org/schema/context/spring-context.xsd    
    http://www.springframework.org/schema/beans    
    http://www.springframework.org/schema/beans/spring-beans.xsd    
    http://www.springframework.org/schema/tx    
    http://www.springframework.org/schema/tx/spring-tx.xsd    
    http://www.springframework.org/schema/jdbc    
    http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd    
    http://www.springframework.org/schema/cache    
    http://www.springframework.org/schema/cache/spring-cache-3.1.xsd    
    http://www.springframework.org/schema/aop    
    http://www.springframework.org/schema/aop/spring-aop.xsd    
    http://www.springframework.org/schema/util    
    http://www.springframework.org/schema/util/spring-util.xsd">
        
        <!-- 添加Spring类注解标签 -->
        <context:annotation-config></context:annotation-config>
        <bean id="injectionService" class="com.test.service.InjectionServiceImpl">
        	<property name="injectionDAO" ref="injectionDAO"></property>
        </bean>
        
        <bean id="injectionDAO" class="com.test.dao.InjectionDAOImpl"></bean>
    </beans>
为了

让Spring能够检测到这些类并添加注册相应的Bean需要添加如下的内容

<!-- 为了让Spring能够检测并注册相应的Bean需要添加如下的内容 -->
        <context:component-scan base-package="org.example.hello(添加包，也可以使用正则表达式)"></context:component-scan>


但是在通常的情况下：<context:component-scan base-package="org.example.hello(添加包，也可以使用正则表达式)"></context:component-scan>

包含了<context:annotation-config></context:annotation-config>，所以通常在使用了前者时候就不再使用后者了。

AutowiredAnnotationbeanPostProcessor和CommonAnnotationbeanPostProcessor也会被包含进来。


其实意思是这样的，在applicationContext的配置文件中添加了：<context:component-scan base-package="org.example.hello(添加包，也可以使用正则表达式)">配置

之后，在启动Spring IOC容器的时候，就会自动去扫描指定的包上的注解，在扫描到符合Bean配置的类的时候就会将其添加在Spring

的配置文件中并将其注册(实例化)。


使用过滤器进行自定义扫描：

默认情况下，类被自动发现并注册bean的条件是： 使用@Component，@RePository，@Service，@Controller注解或者使用@Component的自定义注解


可以通过过滤器修改上面的行为，如：下面的例子的XML配置忽略所有的有@Repository注解并用“”Stub“”代替。

还可以使用use-default-filters="false"禁用自动发现并注册。 
<!-- 为了让Spring能够检测并注册相应的Bean需要添加如下的内容 -->
        <context:component-scan base-package="org.example.hello(添加包，也可以使用正则表达式)">
        	<!-- 使用过滤器，过滤掉一些不需要注册Bean的类 -->
        	<context:exclude-filter type="regex" expression=""/> 使用正则表达式除去不需要的类 -->
        	
        	<!--<context:include-filter type="regex" expression=""/>
        </context:component-scan>

其中过滤的方式有：

Bean的定义：
在扫描过程中组件被自动检测，那么Bean名称是由BeanNameGenerator生成的(@Component,@Repository，@Service
@Controller都有一个name属性用于显示设置Bean Name)：
@Service,@Repository实例： 
@Service(""helloLUOt)
public class Test1
{
    //add somethings
}

@Repository("helloWOrld")
{
    //add somethings
}

你还可以定义Bean的命名策略，实现BeanNameGenerator接口，并一定要包含一个无参数的构造函数。

假如没有指定的话，Spring IOC会根据BeanNameGenerator的BenaName生成策略去生成Bean的对应Name。通常的生成策略是将
这个Bean的首字母小写的这样一个名字。

如下添加一个实现BeanNamegenerator接口的实现Bean的命名策略：

实现BeanNameGenerator接口，编写bean的命名规则： 
package com.test.implBeanNameGenerator;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanNameGenerator;

public class GeneratorBeanName implements BeanNameGenerator {

	@Override
	public String generateBeanName(BeanDefinition arg0,
			BeanDefinitionRegistry arg1) {
		
		return null;
	}

}

在配置文件中添加配置： 
        <!-- 添加beanName的自定义 -->
        <context:component-scan base-package="com.test.implBeanNameGenerator" name-generator="com.test.implBeanNameGenerator.GeneratorBeanName">
        	
        </context:component-scan>
作用域(Scope):

通常情况下自动查找的Spring组件，其scope是singleton的，Spring2.5提供了一个标志scope的注解 @Scope 

@Repository
@Scope("prototype")
public class HelloWorld{
    //do sometingh
}
也可以自定义scope策略，实现ScopeMetadataResolver接口并提供一个无参数的构造
器。
     

代理方式：

可以使用scoped-proxy属性指定代理，有三个值可选：no,interfaces,targetClass.

<!-- 使用interfaces代理 -->
        <context:component-scan base-package="org.demo" scoped-proxy="interfaces"></context:component-scan>
        <!-- 不使用代理:no -->
        <context:component-scan base-package="org.demo" scoped-proxy="no"></context:component-scan>
        <!-- 使用targetClass方式代理 -->
        <context:component-scan base-package="org.demo" scoped-proxy="targetClass"></context:component-scan>


添加测试实例： 
package com.test.annotation;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

@Service("bean")
@Component(""beanname)//这个注解不OK
public class TestBeanAnnotation {
	
	public void say(String word)
	{
		System.out.println("BeanAnnotation: "+word);
	}
}


XML配置： 
<?xml version="1.0" encoding="UTF-8"?>    
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"    
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util" xmlns:jdbc="http://www.springframework.org/schema/jdbc"    
    xmlns:cache="http://www.springframework.org/schema/cache"    
    xsi:schemaLocation="    
    http://www.springframework.org/schema/context    
    http://www.springframework.org/schema/context/spring-context.xsd    
    http://www.springframework.org/schema/beans    
    http://www.springframework.org/schema/beans/spring-beans.xsd    
    http://www.springframework.org/schema/tx    
    http://www.springframework.org/schema/tx/spring-tx.xsd    
    http://www.springframework.org/schema/jdbc    
    http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd    
    http://www.springframework.org/schema/cache    
    http://www.springframework.org/schema/cache/spring-cache-3.1.xsd    
    http://www.springframework.org/schema/aop    
    http://www.springframework.org/schema/aop/spring-aop.xsd    
    http://www.springframework.org/schema/util    
    http://www.springframework.org/schema/util/spring-util.xsd">
        
       <!-- 实现bean的扫描和注册 -->
       <context:component-scan base-package="com.test.annotation"></context:component-scan>
    </beans>


测试类： 

	@Test
	public void testSay()
	{
		//加载配置文件
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext_BeanAnnotation.xml");
		//获得实例
		TestBeanAnnotation ta = (TestBeanAnnotation)ac.getBean("bean");
		
		ta.say("hello world!");
	}


运行结果： 
开始执行: 2016年07月16日 03时:34分:36秒
七月 16, 2016 3:34:36 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@7960847b: startup date [Sat Jul 16 15:34:36 CST 2016]; root of context hierarchy
七月 16, 2016 3:34:37 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext_BeanAnnotation.xml]
BeanAnnotation: hello world!
执行完成: 2016年07月16日 03时:34分:36秒

4、@Component，@Repository,@Service,@Controller

在类中添加这几个注解之后，当Spring IOC容器启动的时候就会去检查并将这些类实例化为Bean提供调用。


5、@Required；

这个注解适用于bean属性的setter方法。这个注解仅仅表示，受影响的bean属性必须在配置时被填充，通过在bean定义或自动装配一个明确的属性值。


6、@Autowired；

可以将这个注解理解为传统的setter方法，可以用于构造器或者成员变量。默认情况下，如果找不到合适的bean将会导致autowiring失败抛出异常，可以通过下面的方式避免。

在使用类的时候，每个类可能有很多个构造器，但是在使用Autowored的时候每一个类只能有一个构造器被标记为required=true，@Autowired的必要属性，建议使用@Required注解。


测试例子：第一种注入方式，在给属性添加@Autowired注解的情况下。

package com.test.dao;

public interface InjectionDAO {

	public void save(String arg);
}



package com.test.dao;

import org.springframework.stereotype.Repository;

@Repository
public class InjectionDAOImpl implements InjectionDAO {

	@Override
	public void save(String arg) {
		
		System.out.println("保存的数据： "+arg);
	}

}


package com.test.service;

public interface InjectionService {

	public void save(String arg);
}


package com.test.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.test.dao.InjectionDAO;

@Service
public class InjectionServiceImpl implements InjectionService {

	@Autowired
	InjectionDAO injectionDAO;

	@Override
	public void save(String arg) {

		System.out.println("接收的数据: "+arg);
		//处理数据
		arg = arg+":"+this.hashCode();
		
		//调用InjectionDAO的save方法处理数据
		injectionDAO.save(arg);//--->配置xml配置文件
	}

}


XML配置文件：

<?xml version="1.0" encoding="UTF-8"?>    
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"    
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util" xmlns:jdbc="http://www.springframework.org/schema/jdbc"    
    xmlns:cache="http://www.springframework.org/schema/cache"    
    xsi:schemaLocation="    
    http://www.springframework.org/schema/context    
    http://www.springframework.org/schema/context/spring-context.xsd    
    http://www.springframework.org/schema/beans    
    http://www.springframework.org/schema/beans/spring-beans.xsd    
    http://www.springframework.org/schema/tx    
    http://www.springframework.org/schema/tx/spring-tx.xsd    
    http://www.springframework.org/schema/jdbc    
    http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd    
    http://www.springframework.org/schema/cache    
    http://www.springframework.org/schema/cache/spring-cache-3.1.xsd    
    http://www.springframework.org/schema/aop    
    http://www.springframework.org/schema/aop/spring-aop.xsd    
    http://www.springframework.org/schema/util    
    http://www.springframework.org/schema/util/spring-util.xsd">
        
        <!-- 配置注解自动扫描 Bean-->
       	<context:component-scan base-package="com.test"></context:component-scan>
    </beans>

测试方法： 

	@Test
	public void testAutowired()
	{
		//加载配置文件
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		//获得实例
		InjectionService is = (InjectionService)ac.getBean("injectionServiceImpl");
		
		//调用保存方法保存数据
		is.save("@Autowired");
	}

测试结果：

开始执行: 2016年07月16日 08时:27分:54秒
七月 16, 2016 8:27:55 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@7960847b: startup date [Sat Jul 16 20:27:55 CST 2016]; root of context hierarchy
七月 16, 2016 8:27:55 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
接收的数据: @Autowired
保存的数据： @Autowired:1848415041
执行完成: 2016年07月16日 08时:27分:54秒

测试例子：第二种注入方式，在给setter方法添加@Autowired注解的情况下。 

package com.test.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.test.dao.InjectionDAO;

@Service
public class InjectionServiceImpl implements InjectionService {

	//@Autowired: 给属性添加注解
	InjectionDAO injectionDAO;

	@Autowired//给setter方法添加注解
	public void setInjectionDAO(InjectionDAO injectionDAO) {
		this.injectionDAO = injectionDAO;
	}

	@Override
	public void save(String arg) {

		System.out.println("接收的数据: "+arg);
		//处理数据
		arg = arg+":"+this.hashCode();
		
		//调用InjectionDAO的save方法处理数据
		injectionDAO.save(arg);//--->配置xml配置文件
	}

}


运行结果：

开始执行: 2016年07月16日 08时:35分:35秒
七月 16, 2016 8:35:35 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@7960847b: startup date [Sat Jul 16 20:35:35 CST 2016]; root of context hierarchy
七月 16, 2016 8:35:35 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
接收的数据: @Autowired
保存的数据： @Autowired:518522822
执行完成: 2016年07月16日 08时:35分:35秒

得到的结果是一样的。



测试例子：第三种注入方式，在构造器上使用@Autowired注解的方式。

package com.test.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.test.dao.InjectionDAO;

@Service
public class InjectionServiceImpl implements InjectionService {

	//@Autowired: 给属性添加注解
	InjectionDAO injectionDAO;

	//@Autowired//给setter方法添加注解
	public void setInjectionDAO(InjectionDAO injectionDAO) {
		this.injectionDAO = injectionDAO;
	}
	
	@Autowired//使用构造器添加注解注入
	public InjectionServiceImpl(InjectionDAO injectionDAO)
	{
		this.injectionDAO = injectionDAO;
	}

	@Override
	public void save(String arg) {

		System.out.println("接收的数据: "+arg);
		//处理数据
		arg = arg+":"+this.hashCode();
		
		//调用InjectionDAO的save方法处理数据
		injectionDAO.save(arg);//--->配置xml配置文件
	}

}


运行结果：

开始执行: 2016年07月16日 09时:10分:00秒
七月 16, 2016 9:10:00 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@7960847b: startup date [Sat Jul 16 21:10:00 CST 2016]; root of context hierarchy
七月 16, 2016 9:10:00 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
接收的数据: @Autowired
保存的数据： @Autowired:1738236591
执行完成: 2016年07月16日 09时:10分:00秒

总结： 使用@Autowired可以完成成员变量注入，setter注入和构造器注入三种方式的注入，最后的运行结果都是相同的。


第二部分：


可以使用@Autowired来注解那些众所周知的解析依赖性接口，比如： BeanFactory,ApplicationContext,Environment,ResourLoader,ApplicationEvent,和MessageSource。


如果希望数组有序，可以让bean实现org.springframework.core.Ordered接口或者使用@Order注解。


@Autowired注解是由Spring的BeanPostProcessor处理的所以不能再自己的BeanPostProcessor类型运用这些注解，这些类型必须通过XML或者@Bean注解加载。


例子：数组及Map的自动注入：

package com.test.multibean;

public interface BeanInterface {

}



package com.test.multibean;

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Order(value=1)
@Component
public class BeanImplOne implements BeanInterface {

}


package com.test.multibean;

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Order(value=2)
@Component
public class BeanImplTwo implements BeanInterface {

}



package com.test.multibean;

import java.util.List;
import java.util.Map;

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

//调用类
@Component
public class BeanInvoker {
	
	//List的方式
	@Autowired
	private List<BeanInterface> list;
	
	//Map的方式
	@Autowired
	private Map<String,BeanInterface> map;
	
	public void say()
	{
		System.out.println("List方式： ");
		if(null != list &&list.size() != 0)
		{
			for (BeanInterface bean : list) {
				System.out.println(bean.getClass().getName());
			}
		}else
		{
			System.out.println("List<BeanInterface> is null!!!!");
		}
		
		
		
		System.out.println("Map方式： ");
		if(null != map &&map.size() !=0)
		{
			//遍历map
			for(Map.Entry<String, BeanInterface> entry:map.entrySet())
			{
				System.out.println(entry.getKey()+"    "+entry.getValue().getClass().getName());
			}
		}else
		{
			System.out.println("Map<String,BeanInterface> map is null!");
		}
	}

}

测试类： 

	@Test
	public void testBeanInvoke()
	{
		//加载配置文件
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		//获得实例
		BeanInvoker bi = (BeanInvoker)ac.getBean("beanInvoker");
		
		bi.say();
	}


测试结果：

开始执行: 2016年07月16日 09时:58分:50秒
七月 16, 2016 9:58:51 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@7960847b: startup date [Sat Jul 16 21:58:51 CST 2016]; root of context hierarchy
七月 16, 2016 9:58:51 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
List方式： 
com.test.multibean.BeanImplOne
com.test.multibean.BeanImplTwo
Map方式： 
beanImplOne    com.test.multibean.BeanImplOne
beanImplTwo    com.test.multibean.BeanImplTwo
执行完成: 2016年07月16日 09时:58分:50秒

7、@Aualifier;

8、@Resource；


从Spring3.0开始，Spring JavaConfig项目提供了很多特性，包括使用Java而不是XML配置文件定义Bean。比如：

@Component,@Bean,@Import,@DependsOn.其中@Component是一个通用注解，可以使用于任何Bean。

@Repository，@Service，@Controller是更有针对性的注解

--@Repository通常用于注解DAO类，即持久层；

--@Service通常用于注解Service类，即服务层；

--@Controller通常用于Controller类，即控制层(MVC);


元注解： 许多Spring提供的注解可以作为自己的代码，即“元数据注解”，元注解是一个简单的注解，可以应用到了一个注解

除了value()，元注解还可以有其他的属性，允许定制。














以墨言智
关注
专栏目录
Spring Bean管理注解方式代码实例
08-19
Spring Bean 管理注解方式代码实例 Spring Bean 管理注解方式代码实例是 Spring 框架中的一种常见的 Bean 管理方式。通过使用注解的方式，可以简化 Bean 的配置和管理过程。这篇文章将详细介绍 Spring Bean 管理...
spring Bean 管理
m0_62520968的博客
05-25 3154
1.Bean 管理指的是两个操作 （1）Spring 创建对象 （2）Spirng 注入属性 2、Bean的实例化 1.构造器实例化 构造器实例化是指Spring容器通过Bean对应类中默认的无参构造方法来实例化Bean。下面通过一个案例来演示Spring容器是如何通过构造器来实例化Bean的。 （1）在Eclipse中，创建一个名为chapter02的Web项目，在该项目的lib目录中加入Spring支持和依赖的JAR包。 （2）在chapter02项目的src目录下，创建一个com.it..
Spring中的Bean的管理（史上最全）
mr_xioabai的博客
03-30 2084
1.BeanFactory接口本文介绍Spring里的BeanFactory。包括：BeanFactory 和 FactoryBean的ApplicationContext的委托。Spring的本质是一个bean工厂(beanFactory)或者说bean容器，它按照我们的要求，生产我们需要的各种各样的bean，提供给我们使用。只是在生产bean的过程中，需要解决bean之间的依赖问题，才引入了依赖注入(DI)这种技术。
Java学习 - Spring Bean 注解详解
最新发布
paofuluolijiang的博客
07-16 2010
本篇博客中，我们将会讨论用于声明不同类型 Beans 的几种最常用的 Spring Bean 注解。众所周知，Spring 容器中有许多配置 Bean 的方法，我们既可以通过 XML 配置，也可以在配置类中使用@Bean注解来声明 Beans。此外，我们还可以使用包中的一个注解来对类进行标记，然后把其余工作交给组件扫描即可。好了，以上就主要介绍了 Spring 中的原型注释，并了解了它们各自所代表的意义。此外，还学习了如何使用组件扫描功能，从而告知 Spring 容器在何处能找到带有注解的类。
Spring常用注解
renxyz的专栏
09-15 1424
看到一篇讲解注解的文章，讲的太好了，文章转载地址 http://www.cnblogs.com/xdp-gacl/p/3495887.html 具体如下： 使用注解来构造IoC容器 用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册。 如：在base-package指明一个包 1 context:component-sca
Spring的四大注释
Wanger_tt的博客
03-30 2294
1.首先让我们看看四大注释是啥Spring给我们提供了四个注释用来表示Bean的存在，他们分别是@Component、@Service、@Constroller还有我们的@Repository2.@Component其中@Component是一个笼统的表示，只是用来表示他所标注的类是一个需要转为Bean的类，但他是什么层次的类我们并不知道，由于现在对系统‘分层’这个强定义观念的存在@Componen
Bean管理注解
m0_67514201的博客
07-22 190
6.注解-@ComponentScan.==4.用于定义生命周期-@PostConstruct(bean被创建的时候执行)&@PreDestroy(bean被销毁的时候执行)；@Qualifier&@Resource先通过name注入，找不到再通过类型。@Component("xxx")除三层以外的其它层实体层。@Service业务逻辑层service的实现类！5.懒加载注解-@Lazy....
Spring @Bean注解配置及使用方法解析
08-19
4. 使用 @Bean 注解在 Bean 初始化和销毁。在方法上使用 @Bean 注解时，可以使用 initMethod 和 destroyMethod 属性指定 Bean 的初始化和销毁方法。例如： ```java public class MyBean { public void init() { ...
简单了解Spring Bean常用注解的装配
08-25
Spring Bean常用注解的装配 ...Spring Bean的常用注解的装配提供了一种更加灵活和高效的方式来管理和装配JavaBean对象。在实际开发中，选择合适的注解来标注和装配Bean，可以提高开发效率和代码维护性。
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
Spring Aop之AspectJ注解配置实现日志管理的方法 Spring Aop是基于AspectJ实现的面向切面编程（AOP），它提供了一个灵活的方式来实现日志管理。通过使用AspectJ注解，可以轻松地实现日志记录、性能监控、安全检查...
Spring @Bean vs @Service注解区别
08-28
"Spring @Bean vs @Service注解区别" 在Spring框架中，@Bean和@Service都是用来创建Bean的注解，但是它们的作用域和使用场景不同。下面将详细介绍这两个注解的区别。 首先，@Bean是Spring框架中的核心注解之一，它...
Spring学习之Bean管理
m0_64460657的博客
03-19 1276
Spring之Bean管理 IOC DI
Spring框架-Spring Bean管理
qq_44715376的博客
01-04 1080
SpringBean
五、Spring中使用注解方式管理bean
老去的90后
12-13 192
Autowired(required = false) 通过required属性设置当前自动装配是否为必须（默认必须——如果没有找到类型与属性类型匹配的bean则抛出异常）​ 方法注解，声明一个方法为当前类的初始化方法（在构造器之后执行），相当于bean标签的init-method属性。@Service注解主要声明业务处理类配置给Spring管理，Service接口的实现类。类注解，用于声明当前类单例模式还是非单例模式，相当于bean标签的scope属性。在该模式下，所有实例都是在获取实例时生成。
Spring四种注解
chikai1的专栏
01-28 1087
Spring主要有四种注解可以注册bean，每种注解可以任意使用，只是语义上有所差异： @Component：可以用于注册所有bean @Repository：主要用于注册dao层的bean @Controller：主要用于注册控制层的bean @Service：主要用于注册服务层的bean   描述依赖关系主要有两种： @Resource：java的注解，默认以byName的方式去...
Spring 中最常用的四个注解 Component、Controller、Repository、Service
khxu666的博客
09-29 9591
总览 Spring 2.5 以后，除了提供基本的 @Component 注解之外，还提供了 @Service @Controller @Repository 三个注解。在 Spring 源码中，后面三个注解都在开始部分引入了 @Component 注解，除此以外这四个注解的源码内容没有任何区别，因此后面的这三个注解与 Component 的作用是一样的。之所以要额外的引出这三个注解，是为了更好的...
【spring】Bean管理注解
清风微醺的博客
08-09 172
基于注解方式实现对象的创建 (1)注解是代码标记，格式:@注解名称(属性名称=属性值,属性名称=属性值) 使用注解的目的:简化xml配置 Bean管理(创建对象) @Component @Service @Controller @Repository 导入依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> &
Spring是如何管理Bean
gysibm的博客
10-14 1571
我们知道，容器是一个空间的概念，一般理解为可盛放物体的地方。在Spring容器通常理解为BeanFactory或者ApplicationContext。我们知道spring的IOC容器能够帮我们创建对象，对象交给spring管理之后我们就不用手动去new对象。 BeanFactory与ApplicationContext的区别是什么？ BeanFactory采用了工厂设计模式，负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的声明周期。而ApplicationC
Spring框架的Bean管理
m0_61983575的博客
02-19 995
(1).什么是Bean个管理 bean管理指的是如下的两个操作 1.创建对象 2.注入属性
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值