Spring 注解

最新推荐文章于 2022-06-01 15:07:40 发布
最新推荐文章于 2022-06-01 15:07:40 发布
阅读量115 收藏
点赞数
分类专栏： Spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33753147/article/details/108058603
版权

相关依赖:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

配置文件方式:

使用xml方式配置bean到IOC容器中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="person" class="com.lb.spring.day1.part1.Person">
		<property name="name" value="lb"></property>
		<property name="age" value="19"></property>
	</bean>
</beans>
public class BeanTest {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
        Person person = (Person) app.getBean("person");
        System.out.println(person);
    }
}

结果:

Person{name='lb', aga=19}

注解方式:

@Configuration

@Configuration 等同于Spring的配置文件.

Spring注入bean的方式

  1. @Bean -- 导入第三方的类或包的组件，比如有一个第三方的类A，需要导入到IOC容器中使用
  2. 包扫描+组件的表示注解(@ComponentScan + @Controller, @Service, @Responsitory, @Component)， 一般针对自己写的类，使用这个
  3. @Import:快速给容器导入一个或多个组件
    1. @Import(要导入的容器的组件):容器会自动注册这个组件，bean的id为全类名
    2. ImportSelector:是一个接口,返回需要导入到容器的组件的全类名数组
    3. ImportBeanDefinitionRegistrar:可以手动添加组件到IOC容器, 所有Bean的注册可以使用BeanDifinitionRegistry
  4. 使用Spring提供的FactoryBean(工厂bean进行注册)

 

@Bean

将Bean注入到IOC容器中

@Configuration
public class MyConfigration1 {
    @Bean //将bean注入到IOC容器中,默认为单例模式,如果不设置bean的id名称默认方法名为bean的id名称
    public Person person01(){
        Person person = new Person("lb",20);
        return person;
    }

    @Bean("myPerson") //设置了Bean的id名称
    public Person person(){
        Person person = new Person("lb",21);
        return person;
    }
}

 

public class Part2Test {
    @Test
    public void test(){
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfigration1.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names){
            System.out.println(name);
        }
        Person person = (Person) app.getBean("person01");
        System.out.println(person);

        Person person2 = (Person) app.getBean("myPerson");
        System.out.println(person2);
    }
}

结果:

myConfigration1
person01
myPerson
Person{name='lb', aga=20}
Person{name='lb', aga=21}

Condition接口

自定义类实现Condition接口，配合@Conditional 和 @Bean使用，可以有条件的注入

/**
 * 如果系统为Windows， 则向IOC容器中注入被注解引用的类
 */
public class WinCondition implements Condition {
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        Environment environment = conditionContext.getEnvironment();
        String name = environment.getProperty("os.name");
        if (name.contains("Windows")){
            return true;
        }
        return false;
    }
}

/**
 * 如果系统为Linux， 则向IOC容器中注入被注解引用的类
 */
public class LinuxCondition implements Condition {
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        Environment environment = conditionContext.getEnvironment();
        String name = environment.getProperty("os.name");
        if (name.contains("Linux")){
            return true;
        }
        return false;
    }
}

@Configuration
public class MyConfigration6 {

    @Bean
    public Person person(){
        return new Person("person",25);
    }

    @Conditional(value = WinCondition.class)
    @Bean("lb")
    public Person lb(){
        return new Person("lb",18);
    }

    @Conditional(value = LinuxCondition.class)
    @Bean("lb2")
    public Person lb2(){
        return new Person("lb2",19);
    }
}

public class Part6Test {
    @Test
    public void test() {
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfigration6.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        System.out.println("IOC容器已经加载完成");
    }
}

接口: 测试机器系统为window7

myConfigration6
person
lb
IOC容器已经加载完成

@ComponentScan

value属性

Spring扫描包的路径

@Configuration
@ComponentScan(value = "com.lb.spring.day1.part3")
public class MyConfigration2 {
    @Bean
    public Person person(){
        Person person = new Person("lb",20);
        return person;
    }
}
@Controller
public class MyController {
}
@Repository
public class MyDao {
}
@Service
public class MyService {
}
public class Part3Test {
    @Test
    public void test(){
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfigration2.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names){
            System.out.println(name);
        }
    }
}

结果:

myConfigration2
myController
myDao
myService
person

includeFilters属性

扫描的包中，包含哪些内容,但是必须和useDefaultFilters属性同时使用，默认为true，需要修改成false. includeFilters才能过滤成功:

@Configuration
@ComponentScan(value = "com.lb.spring.day1.part3",includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
},useDefaultFilters = false)
public class MyConfigration2 {
    @Bean
    public Person person(){
        Person person = new Person("lb",20);
        return person;
    }
}

结果:

只注入了Controller注解的类

myConfigration2
myController
person

excludeFilters属性

扫描的包中，不包含哪些内容，useDefaultFilters=true

FilterType.ANNOTATION 为注解，与classes使用
FilterType.ASSIGNABLE_TYPE为具体的类，与value使用

 

@Configuration
@ComponentScan(value = "com.lb.spring.day1.part3",excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {MyController.class})
})
public class MyConfigration2 {
    @Bean
    public Person person(){
        Person person = new Person("lb",20);
        return person;
    }
}

结果:

myConfigration2
myDao
myService
person

FileType

//FilterType.ANNOTATION：按照注解

//FilterType.ASSIGNABLE_TYPE：按照给定的类型；比如按BookService类型

//FilterType.ASPECTJ：使用ASPECTJ表达式

//FilterType.REGEX：使用正则指定

//FilterType.CUSTOM：使用自定义规则，自已写类，实现TypeFilter接口

自定义规则: implements TypeFilter

public class LbTypeFilter implements TypeFilter {
    /**
     * @param metadataReader 读取到正在扫描类的信息
     * @param metadataReaderFactory
     * @return
     * @throws IOException
     */
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        String className = classMetadata.getClassName();
        System.out.println("--------------------"+className);
        if (className.contains("controller")){
            return true;
        }
        return false;
    }
}
@Configuration
@ComponentScan(value = "com.lb.spring.day1.part3",excludeFilters = {
        @ComponentScan.Filter(type = FilterType.CUSTOM,value = {LbTypeFilter.class})
})
public class MyConfigration2 {
    @Bean
    public Person person(){
        Person person = new Person("lb",20);
        return person;
    }
}

结果:

myConfigration2
myDao
myService
person

@Import

使用@Import直接导入类

public class Dog {
}

public class Cat {
}

@Configuration
@Import(value = {Dog.class, Cat.class})
public class MyConfigration7 {
    @Bean
    public Person person(){
        return new Person("person",25);
    }
}

public class Part7Test {
    @Test
    public void test() throws Exception {
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfigration7.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}

 结果:

可以发下Dog 和 Cat已经注入到Spring容器中，bean的id为类的全类名

myConfigration7
com.lb.spring.day2.part7.bean.Dog
com.lb.spring.day2.part7.bean.Cat
person

ImportSelector 接口

使用ImportSelector接口配合@Import使用，将一组bean注入到IOC容器中, 注意注入类为类的全路径

public class Fish {
}

public class Tiger {
}

public class LbImportSelector implements ImportSelector {
    /**
     * @param annotationMetadata 当前标注@Import注解类的所有注解信息,不止能获取到import注解，还能获取到其他注解
     * @return
     */
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        //批量将bean注入到IOC容器中
        return new String[]{"com.lb.spring.day2.part7.bean.Fish","com.lb.spring.day2.part7.bean.Tiger"};
    }
}

@Configuration
@Import(value = {Dog.class, Cat.class, LbImportSelector.class})
public class MyConfigration7 {
    @Bean
    public Person person(){
        return new Person("person",25);
    }
}

 结果:

Fish 和 Tiger已经注入到IOC容器中，并且bean 的 id是全类名

myConfigration7
com.lb.spring.day2.part7.bean.Dog
com.lb.spring.day2.part7.bean.Cat
com.lb.spring.day2.part7.bean.Fish
com.lb.spring.day2.part7.bean.Tiger
person

 ImportBeanDefinitionRegistrar接口

使用ImportBeanDefinitionRegistrar接口配合@Import，可以将多个Bean加入到IOC容器中，并且可以设置bean的id

public class Pig {
}

public class LbImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    /**
     * @param annotationMetadata 当前类的注解信息
     * @param beanDefinitionRegistry BeanDefinitionz注册类 把所有需要添加到容器中的bean调用registerBeanDefinition自定义手工注册到IOC容器中
     */
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        boolean dogFlag = beanDefinitionRegistry.containsBeanDefinition("com.lb.spring.day2.part7.bean.Dog");
        boolean catFlag = beanDefinitionRegistry.containsBeanDefinition("com.lb.spring.day2.part7.bean.Cat");
        if (dogFlag && catFlag){//如果IOC容器中已经注入了Dog和Cat
            RootBeanDefinition beanDefinition = new RootBeanDefinition(Pig.class);
            beanDefinitionRegistry.registerBeanDefinition("pig",beanDefinition);
        }
    }
}

@Configuration
@Import(value = {Dog.class, Cat.class, LbImportSelector.class, LbImportBeanDefinitionRegistrar.class})
public class MyConfigration7 {
    @Bean
    public Person person(){
        return new Person("person",25);
    }
}

结果：

在自定义的ImportBeanDefinitionRegistrar中判断容器中是否已经存在Dog和Cat，如果存在则将Pig加入到IOC容器中，bean的id为pig

myConfigration7
com.lb.spring.day2.part7.bean.Dog
com.lb.spring.day2.part7.bean.Cat
com.lb.spring.day2.part7.bean.Fish
com.lb.spring.day2.part7.bean.Tiger
person
pig

 自定义FactoryBean

通过实现的FactoryBean接口，往IOC容器中注册类

public class Monkey {
    private String name;

    public Monkey() {
    }

    public Monkey(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class LbBeanFactory implements FactoryBean<Monkey> {
    public Monkey getObject() throws Exception {
        return new Monkey("taotao");
    }

    public Class<?> getObjectType() {
        return Monkey.class;
    }

    public boolean isSingleton() {
        return false;
    }
}

@Configuration
@Import(value = {Dog.class, Cat.class, LbImportSelector.class, LbImportBeanDefinitionRegistrar.class})
public class MyConfigration7 {
    @Bean
    public Person person(){
        return new Person("person",25);
    }
    @Bean
    public LbBeanFactory lbBeanFactory(){
        return new LbBeanFactory();
    }
}

public class Part7Test {
    @Test
    public void test() throws Exception {
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfigration7.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        //获取BeanFactory 注入的对象
        Monkey monkey = (Monkey) app.getBean("lbBeanFactory");
        System.out.println(monkey.getClass().getName());
        System.out.println(monkey.getName());
        System.out.println("---------------------------");
        //获取LbBeanFactory本身对象
        LbBeanFactory lbBeanFactory = (LbBeanFactory) app.getBean("&lbBeanFactory");
        System.out.println(lbBeanFactory.getClass().getName());
        System.out.println("IOC容器已经加载完成");
    }
}

结果:

可以从容器中得到id为lbBeanFactory的Moneky实例，并且通过id="&lbBeanFactory"可以从容器中得到自定义BeanFactory(LbBeanFactory)的实例

myConfigration7
com.lb.spring.day2.part7.bean.Dog
com.lb.spring.day2.part7.bean.Cat
com.lb.spring.day2.part7.bean.Fish
com.lb.spring.day2.part7.bean.Tiger
person
lbBeanFactory
pig
com.lb.spring.day2.part7.bean.Monkey
taotao
---------------------------
com.lb.spring.day2.part7.LbBeanFactory
IOC容器已经加载完成

@Scope

 //给容器中注册一个bean, 类型为返回值的类型, 默认是单实例
    /*
     * prototype:多实例: IOC容器启动的时候,IOC容器启动并不会去调用方法创建对象, 而是每次获取的时候才会调用方法创建对象
     * singleton:单实例(默认):IOC容器启动的时候会调用方法创建对象并放到IOC容器中,以后每次获取的就是直接从容器中拿同一个bean
     * request: 主要针对web应用, 递交一次请求创建一个实例
     * session:同一个session创建一个实例
     */

默认配置:单例

@Configuration
public class MyConfigration3 {
    @Scope
    @Bean
    public Person person(){
        Person person = new Person("lb",20);
        return person;
    }
}

public class Part4Test {
    @Test
    public void test() {
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfigration3.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        Person person = (Person) app.getBean("person");
        Person person2 = (Person) app.getBean("person");
        System.out.println(person == person2);
    }
}

结果:

myConfigration3
person
true

多实例:

@Configuration
public class MyConfigration3 {
    @Scope("prototype")
    @Bean
    public Person person(){
        Person person = new Person("lb",20);
        return person;
    }
}

public class Part4Test {
    @Test
    public void test() {
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfigration3.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        Person person = (Person) app.getBean("person");
        Person person2 = (Person) app.getBean("person");
        System.out.println(person == person2);
    }
}

结果:

myConfigration3
person
false

@Lazy

延迟加载，一般的Bean在spring容器初始化时会加载到容器中，但是使用@Lazy在容器启动时不会立刻实例化，只有再被调用的时候才会被实例化到容器中

在不使用@Lazy时:

@Configuration
public class MyConfigration4 {

    @Bean
    public Person person(){
        Person person = new Person("lb",25);
        System.out.println("Person add to IOC");
        return person;
    }
}

public class Part5Test {
    @Test
    public void test() {
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfigration4.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        System.out.println("IOC容器已经加载完成");
        Person person = (Person) app.getBean("person");
        System.out.println(person);
    }
}

结果:

在容器初始化时已经将Person注入到容器中

Person add to IOC
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalRequiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
myConfigration4
person
IOC容器已经加载完成
Person{name='lb', aga=25}

使用@Lazy:

@Configuration
public class MyConfigration4 {

    @Lazy
    @Bean
    public Person person(){
        Person person = new Person("lb",25);
        System.out.println("Person add to IOC");
        return person;
    }
}

public class Part5Test {
    @Test
    public void test() {
        ApplicationContext app = new AnnotationConfigApplicationContext(MyConfigration4.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
        System.out.println("IOC容器已经加载完成");
        Person person = (Person) app.getBean("person");
        System.out.println(person);
    }
}

结果:

容器先初始化成功，在调用时才将Person添加到IOC 容器中

myConfigration4
person
IOC容器已经加载完成
Person add to IOC
Person{name='lb', aga=25}

@Value

使用@Value给类的属性赋值

  1. 直接赋值基本字符 : wangcai
  2. 使用SpringEL表达式:#{10-5} 等等
  3. 读取配置文件中的值: ${xxx.xxx},  //读取到的值被存储在环境变量中
@Configuration
//使用@PropertySource进行配置文件的读取，可以读取多个文件
@PropertySource(value = {"classpath:/test.properties"})
public class MyConfigration13 {
    @Bean
    public Dog dog(){
        return new Dog();
    }
}

public class Dog {
    //直接赋值字符串
    @Value("wangcai")
    private String name;
    //使用SpringEL表达式赋值
    @Value("#{10-5}")
    private Integer age;
    //从配置文件中读取
    @Value("${dog.color}")
    private String color;

    public Dog() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }
}

public class Part13Test {
    @Test
    public void test() throws Exception {
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(MyConfigration13.class);
        String[] names = app.getBeanDefinitionNames();
        for (String name : names){
            System.out.println(name);
        }
        Dog dog = (Dog) app.getBean("dog");
        System.out.println(dog);
        ConfigurableEnvironment environment = app.getEnvironment();
        //Spring读取的配置文件信息，存储在环境变量中
        System.out.println("environment--->"+environment.getProperty("dog.color")); 
        System.out.println("IOC 容器初始化完成....");
    }
}

 结果:

根据@Value给Dog属性分别赋值,使用@PropertySource读取配置文件

myConfigration13
dog
Dog{name='wangcai', age=5, color='yellow'}
environment--->yellow
IOC 容器初始化完成....

 

naki_bb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring注解笔记
10-20
### Spring注解知识点详解 #### 1. Spring注解基础 在Spring框架中，注解是一种轻量级的依赖注入方式，能够简化配置并提高开发效率。在本节中，我们主要介绍几个Spring中常用的注解，它们分别是@Component、@...
Spring 注解.xmind
07-12
Spring注解大全，注解整理方式采用思维导图工具（XMind）整理，对注解按自己的方式进行了分类，并对所有的注解在备注中进行了解释说明；
SpringBoot--文件上传
aruba的博客
06-01 248
前面已经使用过SpringMVC的文件上传，SpringBoot中文件上传和SpringMVC中基本一样，只是少了一些依赖导入 一、项目配置 1. 导入依赖 只需要导入文件服务器转存的依赖： <dependency> <groupId>com.sun.jersey</groupId> <artifactId&...
Spring 注解大全
qq_42750363的博客
09-28 238
Spring使用的注解大全和解释 注解 解释 @Controller 组合注解（组合了@Component注解），应用在MVC层（控制层）,DispatcherServlet会自动扫描注解了此注解的类，然后将web请求映射到注解了@RequestMapping的方法上。 @Service 组合注解（组合了@Component注解），应用在service层（业务逻辑层） @Reponsitory 组合注解（组合了@Component注解），应用在dao层（数据访问层） @Component 表示一个带注释的类
Spring 常用注解：
li12244的博客
05-12 336
Spring 常用注解：
Spring 5.0 注解配置bean 04
嘿丷如歌的博客
11-04 1714
Spring 配置文件 base-package属性指定一个需要扫描的基类包，Spring容器将会扫描这个基类包里及其子包中的所有类 　　　　当需要扫描多个包时，可以使用逗号分隔 　　　　如果仅希望扫描特定的类而非基包下的所有类，可使用resource-pattern属性过滤特定的类，示例： 　　　　 　　　　子节点表示要包含的目标类 　　　　子节点表示要排除在外的目标类 　　　　下
Spring中注解配置
zengg123的博客
09-24 239
导包和约束：aop包+context约束 @controller 对应web层 @service 对应service @responsitory 对应dao @component //在构造方法中调用 @PostConstruct(); //在销毁方法前调用 @PreDestory(); 2.属性配置 属性注入 @value();使用暴力反射去注入,推荐在set方法中注入 @component(); @Autowrided();自动装配 @Resource（）；手动指定 3.Spring 整合Junit.
Spring注解驱动开发
03-24
《Spring注解驱动开发》是一套帮助我们深入了解Spring原理机制的教程； 现今SpringBoot、SpringCloud技术非常火热，作为Spring之上的框架，他们大量使用到了Spring的一些底层注解、原理，比如@Conditional、@Import...
Spring注解依赖包
01-13
Spring注解所依赖的包。com.springSource.javax.annotation
Spring注解驱动笔记.md
01-06
Spring注解描述，底层笔记
SpringBoot系列(8)：SpringBoot中的MVC支持【组件型注解、请求和参数型注解】详解
一切有为法，如梦亦如幻，如露亦如电，应作如是观。
04-19 3892
前言 SpringBoot的MVC 支持主要来自于实地项目开发中我们最常用的几个注解，这些注解可以分为两类： 1. 组件型注解 @Component：没有明确的角色定，在类定义之前添加@Component注解，它会被spring容器识别，并转为bean。 @Repository：用于数据访问层(DAO层)的注解 (特殊的@Component) @Service：用于对业务逻辑层的注解，...
Spring与SpringMVC注解的理解
段小宝的博客
03-14 203
https://www.cnblogs.com/fightingcoding/p/component-scan.html **context:component-scan**查找注解 context:component-scan查找使用构造型（stereotype）注解所标注的类，如@Component(组件)，@Service（服务），@Controller（控制器），@Repository...
@repository的含义,并且有时候却不用写,为什么?
热门推荐
f45056231p的博客
08-14 14万+
//最后发现是这样的:@repository跟@Service,@Compent,@Controller这4种注解是没什么本质区别,都是声明作用,取不同的名字只是为了更好区分各自的功能.下图更多的作用是mapper注册到类似于以前mybatis.xml中的mappers里. //也是因为接口没办法在spring.xml中用bean的方式来配置实现类吧(接口配不了),所以只能用注解或者myba...
java中的注解大全@controller、@service、@repository等
ss_aa_aa的博客
09-26 4万+
参考一篇文章，其中讲了@controller、@service、@repository注解，看后很有启发，自己复制下总结下，添加点东西写下这篇博客 controller层使用@controller注解 @Controller 用于标记在一个类上，使用它标记的类就是一个SpringMVC Controller 对象。分发处理器将会扫描使用了该注解的类的方法。通俗来说，被Controller标
@Repository注解的作用
wqh0830的博客
07-16 14万+
@Repository和@Controller、@Service、@Component的作用差不多，都是把对象交给spring管理。@Repository用在持久层的接口上，这个注解是将接口的一个实现类交给spring管理。 为什么有时候我们不用@Repository来注解接口,我们照样可以注入到这个接口的实现类呢? 1、spring配置文件中配置了MapperScannerConfigure...
@Repository、@Service、@Controller 和 @Component
zb402230366的专栏
11-20 3733
@Repository、@Service、@Controller 和 @Component 将类标识为Bean Spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO类上即可。同时，为了让 Spring 能够扫描类
@Repository注解的作用及含义
TzBugs的博客
06-27 5万+
@Repository(value="userDao")该注解是告诉Spring，让Spring创建一个名字叫“userDao”的UserDaoImpl实例。当Service需要使用Spring创建的名字叫“userDao”的UserDaoImpl实例时，就可以使用@Resource(name = "userDao")注解告诉Spring，Spring把创建好的userDao注入给Service即...
注解的使用
Jintao_Ma的博客
04-08 1485
纸上得来终觉浅 1.基本注解 @Component  标识了一个受Spring管理的组件 @Respository 标识持久层组件 @Service 标识服务层组件 @Controller 标识表现层组件 @Autowires  将bean注入 @Qualifier 指定注入的bean的名字 受标识的组件遵循Spring命名策略，将类的第一个字母小写，或者手动指定名字。   之后
Spring注解原理与应用详解
JAVA SSM之spring注解 Spring注解是Spring Framework中的一种机制，用于简化应用程序的开发和配置。它提供了一种声明式的编程模型，让开发者可以使用注解来定义Bean、自动装配依赖项、实现AOP等功能。 在Spring中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值