国产无码综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

<strike id="m64rs"></strike>

<address id="m64rs"></address>

<blockquote id="m64rs"><dd id="m64rs"></dd></blockquote>

Spring學(xué)習(xí)筆記之Spring IoC注解式開發(fā)

2年前作者：優(yōu)降寧分類：Toy博客閱讀(29)違法舉報

這篇具有很好參考價值的文章主要介紹了Spring學(xué)習(xí)筆記之Spring IoC注解式開發(fā)。希望對大家有所幫助。如果存在錯誤或未考慮完全的地方，請大家不吝賜教，您也可以點擊"舉報違法"按鈕提交疑問。

注解的存在主要是為了簡化XML的配置。Spring6倡導(dǎo)全注解開發(fā)

注解怎么定義，注解中的屬性怎么定義？
注解怎么使用
通過反射機制怎么讀取注解
注解怎么定義，注解中的屬性怎么定義？

package com.powernode.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(value = {ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Component {
    String value();
}

以上是自定義了一個注解：Component

該注解上面修飾的注解包括：Target注解和Retention注解，這兩個注解被稱為元注解。

Target注解用來設(shè)置Component注解可以出現(xiàn)的位置，以上代表表示Component注解只能用在類和接口上。

Retention注解用來設(shè)置Component注解的保持性策略，以上代表Component注解可以被反射機制讀取。

String value（）；是Component注解中的一個屬性。該屬性類型String屬性名是value。

//使用User
package com.powernode.bean;

import com.powernode.annotation.Component;

@Component(value = "userBean")
public class User {
}

語法格式：@注解類型名（屬性名=屬性值，屬性名=屬性值，屬性名=屬性值....）
userBean為什么使用雙引號括起來，因為value屬性是String類型，字符串

另外如果屬性名是value，則在使用的時候可以省略屬性名

package com.powernode.bean;

import com.powernode.annotation.Component;

//@Component(value = "userBean")
@Component("userBean")
public class User {
}

通過反射機制怎么讀取注解？

//有注解的Bean
package com.powernode.bean;

import com.powernode.annotation.Component;

@Component("userBean")
public class User {
}

//沒有注解的Bean
package com.powernode.bean;

public class Vip {
}

//反射解析注解
package com.powernode.test;

import com.powernode.annotation.Component;

import java.io.File;
import java.net.URL;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * @author 動力節(jié)點
 * @version 1.0
 * @className Test
 * @since 1.0
 **/
public class Test {
    public static void main(String[] args) throws Exception {
        // 存放Bean的Map集合。key存儲beanId。value存儲Bean。
        Map<String,Object> beanMap = new HashMap<>();

        String packageName = "com.powernode.bean";
        String path = packageName.replaceAll("\\.", "/");
        URL url = ClassLoader.getSystemClassLoader().getResource(path);
        File file = new File(url.getPath());
        File[] files = file.listFiles();
        Arrays.stream(files).forEach(f -> {
            String className = packageName + "." + f.getName().split("\\.")[0];
            try {
                Class<?> clazz = Class.forName(className);
                if (clazz.isAnnotationPresent(Component.class)) {
                    Component component = clazz.getAnnotation(Component.class);
                    String beanId = component.value();
                    Object bean = clazz.newInstance();
                    beanMap.put(beanId, bean);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        System.out.println(beanMap);
    }
}

聲明Bean的注解

負責(zé)聲明Bean的注解，常見的包括四個

@Component
@Controller
@Service
@Respository

Component注解

package com.powernode.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(value = {ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Component {
    String value();
}

Controller注解

package org.springframework.stereotype;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

Service注解

package org.springframework.stereotype;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Service {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

Repository

package org.springframework.stereotype;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

其實@Controller、@Service、@Repository這三個注解都是@Component注解的別名

也就是說：這四個注解的功能都一樣，用哪個都可以
只是為了增強程序的可讀性，建議

控制類上使用：Controller
service類上使用：Service
dao類上使用Respsitory
它們都是只有一個value屬性。value屬性用來指定bean的id，也就是bean的名字

Spring注解的使用

第一步：加入aop的依賴
第二步：在配置文件中添加context命名空間
第三步：在配置文件中指定掃描的包
第四步：在Bean類上使用注解

第一步：加入aop的依賴
當(dāng)加入spring-context依賴之后，會關(guān)聯(lián)加入aop的依賴。所以不需要再加什么另外的依賴

第二步：在配置文件中添加context命名空間

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

</beans>

第三步：在配置文件中指定要掃描的包

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.powernode.spring6.bean"/>
</beans>

第四步：在Bean類上使用注解

package com.powernode.spring6.bean;

import org.springframework.stereotype.Component;

@Component(value = "userBean")
public class User {
}

//test
package com.powernode.spring6.test;

import com.powernode.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AnnotationTest {
    @Test
    public void testBean(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        User userBean = applicationContext.getBean("userBean", User.class);
        System.out.println(userBean);
    }
}

如果注解的屬性名是value，那么value是可以省略的。

package com.powernode.spring6.bean;

import org.springframework.stereotype.Component;

@Component("vipBean")
public class Vip {
}

package com.powernode.spring6.test;

import com.powernode.spring6.bean.Vip;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AnnotationTest {
    @Test
    public void testBean(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Vip vipBean = applicationContext.getBean("vipBean", Vip.class);
        System.out.println(vipBean);
    }
}

如果把value屬性徹底去掉，spring會被Bean自動取名，默認名字的規(guī)律是Bean類名首字母小寫即可

如果是多個包怎么辦？有兩種解決方案：

第一種：在配置文件中指定多個包，用逗號隔開
第二種：指定多個包的共同父包

用逗號隔開

package com.powernode.spring6.bean2;

import org.springframework.stereotype.Service;

@Service
public class Order {
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.powernode.spring6.bean,com.powernode.spring6.bean2"/>
</beans>


//test
package com.powernode.spring6.test;

import com.powernode.spring6.bean.BankDao;
import com.powernode.spring6.bean2.Order;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AnnotationTest {
    @Test
    public void testBean(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        BankDao bankDao = applicationContext.getBean("bankDao", BankDao.class);
        System.out.println(bankDao);
        Order order = applicationContext.getBean("order", Order.class);
        System.out.println(order);
    }
}

指定父包

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.powernode.spring6"/>
</beans>

選擇性實例化Bean

假設(shè)在某個包下有很多Bean,有的Bean上標(biāo)注了Component,有的標(biāo)注了Controller,有的標(biāo)注了Service,有的標(biāo)注了Repository,現(xiàn)在由于某種特殊業(yè)務(wù)的需求,只允許其中所有的Controller參與Bean管理,其他的都不是實例化。該如何實現(xiàn)

package com.powernode.spring6.bean3;

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

@Component
public class A {
    public A() {
        System.out.println("A的無參數(shù)構(gòu)造方法執(zhí)行");
    }
}

@Controller
class B {
    public B() {
        System.out.println("B的無參數(shù)構(gòu)造方法執(zhí)行");
    }
}

@Service
class C {
    public C() {
        System.out.println("C的無參數(shù)構(gòu)造方法執(zhí)行");
    }
}

@Repository
class D {
    public D() {
        System.out.println("D的無參數(shù)構(gòu)造方法執(zhí)行");
    }
}

@Controller
class E {
    public E() {
        System.out.println("E的無參數(shù)構(gòu)造方法執(zhí)行");
    }
}

@Controller
class F {
    public F() {
        System.out.println("F的無參數(shù)構(gòu)造方法執(zhí)行");
    }
}

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

    <context:component-scan base-package="com.powernode.spring6.bean3" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    
</beans>

其中:

use-default-filters="true"表示:使用spring默認的規(guī)則,只要有Compoment、Controller、Service、Repository中的任意一個注解標(biāo)注,則進行實例化。

use-default-filters="false"標(biāo)識:不再spring默認實例化規(guī)則,即使有Component、Controller、Service、Repository這些注解標(biāo)注，也不再實例化.

<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>表示只有Controller進行實例化。

//test
@Test
public void testChoose(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-choose.xml");
}

也可以將use-default-filters設(shè)置為true(不寫就是true),并且采用exclude-filter方式排除哪些注解標(biāo)注的Bean不參與實例化:

<!-- spring-choose.xml -->
<context:component-scan base-package="com.powernode.spring6.bean3">
  <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
  <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
  <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

負責(zé)注入的注解

@Component@Controller@Service@Repository這四個注解是用來聲明Bean的，聲明后這些Bean將被實例化。

給Bean屬性賦值需要用到這些注解:

@Value
@Autowired
@Qualifier
@Resource

@Value

當(dāng)屬性的類型是簡單類型時,可以使用@Value注解進行注入

//User
package com.powernode.spring6.bean4;

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

@Component
public class User {
    @Value(value = "zhangsan")
    private String name;
    @Value("20")
    private int age;

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

開啟包掃描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.powernode.spring6.bean4"/>
</beans>

//test
@Test
public void testValue(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-injection.xml");
    Object user = applicationContext.getBean("user");
    System.out.println(user);
}

通過測試可以發(fā)現(xiàn)，我們并沒有給屬性提供setter方法，但仍然可以完成屬性賦值
如果提供setter方法，并且再setter方法上添加@Value注解，更能完成此功能

package com.powernode.spring6.bean4;

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

@Component
public class User {
    
    private String name;

    private int age;

    @Value("李四")
    public void setName(String name) {
        this.name = name;
    }

    @Value("30")
    public void setAge(int age) {
        this.age = age;
    }

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

@Value可以直接使用在屬性上，也可以使用在setter方法上，都是可以的，都可以完成屬性的賦值

為了簡化代碼，一般是不提供setter方法，直接在屬性上使用@Value注解完成屬性賦值。

package com.powernode.spring6.bean4;

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

@Component
public class User {

    private String name;

    private int age;

    public User(@Value("隔壁老王") String name, @Value("33") int age) {
        this.name = name;
        this.age = age;
    }

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

@Value注解可以出現(xiàn)在屬性上、setter方法上、以及構(gòu)造方法的形參上。

@Autowired與@Quaifier

@Autowired注解可以用來注入非簡單類型（翻譯為：自動連線的，或者自動裝配）

單獨使用@Autowired注解，默認根據(jù)類型裝配。（默認是byType）

//@Autowired源碼
package org.springframework.beans.factory.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
	boolean required() default true;
}

源碼中有兩處需要注意：

該注解可以標(biāo)注在哪里？

構(gòu)造方法上
方法上
形參上
屬性上
注解上

該注解有一個required屬性，默認值是true，表示在注入的時候要求被注入的Bean必須是存在的，如果不存在則報錯。如果required屬性設(shè)置為false，表示注入的Bean存在或者不存在都沒關(guān)系，存在的話就注入，不存在的話也不報錯

在屬性上使用@Autowired注解

//
package com.powernode.spring6.dao;

public interface UserDao {
    void insert();
}

package com.powernode.spring6.dao;

import org.springframework.stereotype.Repository;

@Repository //納入bean管理
public class UserDaoForMySQL implements UserDao{
    @Override
    public void insert() {
        System.out.println("正在向mysql數(shù)據(jù)庫插入User數(shù)據(jù)");
    }
}

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service // 納入bean管理
public class UserService {

    @Autowired // 在屬性上注入
    private UserDao userDao;
    
    // 沒有提供構(gòu)造方法和setter方法。

    public void save(){
        userDao.insert();
    }
}

<!-- 配置包掃描 -->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.powernode.spring6.dao,com.powernode.spring6.service"/>
</beans>

//test
@Test
public void testAutowired(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-injection.xml");
    UserService userService = applicationContext.getBean("userService", UserService.class);
    userService.save();
}

沒有提供構(gòu)造方法和setter方法，仍然可以注入成功

@Autowired注解出現(xiàn)在setter方法上

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private UserDao userDao;

    @Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save(){
        userDao.insert();
    }
}

@Autowired出現(xiàn)在構(gòu)造方法上

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private UserDao userDao;

    @Autowired
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save(){
        userDao.insert();
    }
}

@Autowired只標(biāo)注在構(gòu)造方法的形參上

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private UserDao userDao;

    public UserService(@Autowired UserDao userDao) {
        this.userDao = userDao;
    }

    public void save(){
        userDao.insert();
    }
}

當(dāng)參數(shù)的構(gòu)造方法只有一個時，@Autowired注解可以省略

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private UserDao userDao;

    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save(){
        userDao.insert();
    }
}

如果有多個構(gòu)造方法，@Autowired肯定是不能省略的

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private UserDao userDao;

    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
    
    public UserService(){
        
    }

    public void save(){
        userDao.insert();
    }
}

@Autowired注解默認是byType進行注入的，也就是說根據(jù)類型注入的，
如果以上程序中，UserDao接口還有另外一個實現(xiàn)類，會出現(xiàn)什么問題

會提示出錯：不能裝配，UseDao這個Bean的數(shù)量大于一
怎么解決這個問題，當(dāng)然要byName，根據(jù)名稱進行裝配。

@Autowired注解和@Qualifier注解聯(lián)合起來才可以根據(jù)名稱進行裝配，在@Qualifier注解中指定Bean名稱

package com.powernode.spring6.dao;

import org.springframework.stereotype.Repository;

@Repository // 這里沒有給bean起名，默認名字是：userDaoForOracle
public class UserDaoForOracle implements UserDao{
    @Override
    public void insert() {
        System.out.println("正在向Oracle數(shù)據(jù)庫插入User數(shù)據(jù)");
    }
}

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private UserDao userDao;

    @Autowired
    @Qualifier("userDaoForOracle") // 這個是bean的名字。
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save(){
        userDao.insert();
    }
}

總結(jié)：

@Autowired注解可以出現(xiàn)在：屬性上、構(gòu)造方法上、構(gòu)造方法的參數(shù)上、setter方法上。
當(dāng)帶參數(shù)的構(gòu)造方法只有一個，@Autowired注解可以省略
@Autowired注解默認根據(jù)類型注入。如果要根據(jù)名稱注入的話，需要配合@Qualifier注解一起使用。

@Resource

@Resource注解也可以完成非簡單類型注入。那它和@Autowired注解有什么區(qū)別

@Resource注解是JDK拓展包中的，也就是說屬于JDK的一部分。所有該注解是標(biāo)準(zhǔn)注解，更加具有通用性。（JSR-250標(biāo)準(zhǔn)中制定的注解類型。JSR是Java規(guī)范提案。）
@Autowired注解是Spring框架自己的
@Resorce注解默認根據(jù)名稱裝配byName，未指定name時，使用屬性名作為name。通過name找不到的話會自動啟動通過類型byType裝配。
@Autowired注解默認根據(jù)類型裝配byType，如果想根據(jù)名稱裝配，需要配合@Qualifier注解一起用
@Resource注解用在屬性上、setter方法上。
@Autowired注解用在屬性上、setter方法上、構(gòu)造方法上、構(gòu)造方法參數(shù)上

@Resource注解屬于JDK拓展包，所以不再JDK當(dāng)中，需要額外引入以下依賴（如果時JDK8的話不需要額外引入依賴。高于JDK11或低于JDK8需要引入以下依賴）：

<!-- spring-6 -->
<dependency>
  <groupId>jakarta.annotation</groupId>
  <artifactId>jakarta.annotation-api</artifactId>
  <version>2.1.1</version>
</dependency>

一定要注意：如果你用Spring6，要知道Spring6不再支持JavaEE，它支持的是JakartaEE9。
（Oracle把JavaEE貢獻給Apache了，Apache把JavaEE的名字改成JaKartaEE了，所以之前所接觸的所有javax.*包名統(tǒng)一修改為jakarta.*包名了）

<!-- spring-5 -->
<dependency>
  <groupId>javax.annotation</groupId>
  <artifactId>javax.annotation-api</artifactId>
  <version>1.3.2</version>
</dependency>

package com.powernode.spring6.dao;

import org.springframework.stereotype.Repository;

@Repository("xyz")
public class UserDaoForOracle implements UserDao{
    @Override
    public void insert() {
        System.out.println("正在向Oracle數(shù)據(jù)庫插入User數(shù)據(jù)");
    }
}

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Resource(name = "xyz")
    private UserDao userDao;

    public void save(){
        userDao.insert();
    }
}

把UseDaoForOracle的名字xyz修改為userDao，讓這個Bean的名字和UserService類中的UseDao屬性名一致：

package com.powernode.spring6.dao;

import org.springframework.stereotype.Repository;

@Repository("userDao")
public class UserDaoForOracle implements UserDao{
    @Override
    public void insert() {
        System.out.println("正在向Oracle數(shù)據(jù)庫插入User數(shù)據(jù)");
    }
}

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Resource
    private UserDao userDao;

    public void save(){
        userDao.insert();
    }
}

當(dāng)@Resource注解使用時沒有指定name的時候，還是根據(jù)name進行查找，這個name是屬性名

當(dāng)通過name找不到的時候，自然會啟動byType進行注入。

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private UserDao userDao;

    @Resource
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save(){
        userDao.insert();
    }
}

setUserDao去掉set之后，將首字母小寫userDao，userDao就是name

也可以指定name

package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private UserDao userDao;

    @Resource(name = "userDaoForMySQL")
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save(){
        userDao.insert();
    }
}

@Resource注解：默認byName注入，沒有指定name時把屬性名當(dāng)作name，根據(jù)name找不到時，才會byType注入。byType注入時，某種類型的Bean只能有一個

全注解式開發(fā)

省略省略省略省略，還有這個，全部省略
所謂的全注解開發(fā)就是不再使用spring配置文件了。寫一個配置類來代替配置文件

package com.powernode.spring6.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScans;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan({"com.powernode.spring6.dao", "com.powernode.spring6.service"})
public class Spring6Configuration {
}

編寫test程序時不用再new ClassPathXmlApplicationContext()對象了文章來源地址http://www.zghlxwxcb.cn/news/detail-652712.html

@Test
public void testNoXml(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Configuration.class);
    UserService userService = applicationContext.getBean("userService", UserService.class);
    userService.save();
}

到了這里，關(guān)于Spring學(xué)習(xí)筆記之Spring IoC注解式開發(fā)的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！

本文來自互聯(lián)網(wǎng)用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務(wù)，不擁有所有權(quán)，不承擔(dān)相關(guān)法律責(zé)任。如若轉(zhuǎn)載，請注明出處：如若內(nèi)容造成侵權(quán)/違法違規(guī)/事實不符，請點擊違法舉報進行投訴反饋，一經(jīng)查實，立即刪除！

分享到：

領(lǐng)支付寶紅包贊助服務(wù)器費用

【Spring教程九】Spring框架實戰(zhàn)：全面深入詳解IOC/DI注解開發(fā)
歡迎大家回到《 Java教程之Spring30天快速入門》，本教程所有示例均基于Maven實現(xiàn)，如果您對Maven還很陌生，請移步本人的博文《如何在windows11下安裝Maven并配置以及 IDEA配置Maven環(huán)境》，本文的上一篇為《 IOC/DI配置管理第三方bean 加載properties文件》。 Spring的IOC/DI對應(yīng)的配置開
2024年02月03日
瀏覽(26)
使用 spring 的 IoC 的實現(xiàn)賬戶的CRUD（2）雙層實現(xiàn)+注解開發(fā)
在http://t.csdn.cn/yucl4的基礎(chǔ)上進行注解開發(fā) 【分析】 xml文件其中spring容器中的bean, 因此通過注解把這些放到容器中即可 @component:相當(dāng)xml中的bean的id: 如果不指定 value 屬性，默認 bean 的 id 是當(dāng)前類的類名, 首字母小寫。 @Controller @Service @Repository是三個衍生 @Autowired 自動按照類型
2024年02月03日
瀏覽(27)
11Spring IoC注解式開發(fā)(上)(元注解/聲明Bean的注解/注解的使用/負責(zé)實例化Bean的注解)
注解的存在主要是為了簡化XML的配置。Spring6倡導(dǎo)全注解開發(fā)。注解開發(fā)的優(yōu)點 :提高開發(fā)效率注解開發(fā)的缺點 :在一定程度上違背了OCP原則，使用注解的開發(fā)的前提是需求比較固定，變動較小。自定義一個注解: 該注解上面修飾的注解包括：Target注解和Retention注解，這兩個注
2024年01月21日
瀏覽(30)
【Spring教程11】Spring框架實戰(zhàn)：IOC/DI注解開發(fā)管理第三方bean的全面深入詳解
歡迎大家回到《 Java教程之Spring30天快速入門》，本教程所有示例均基于Maven實現(xiàn)，如果您對Maven還很陌生，請移步本人的博文《如何在windows11下安裝Maven并配置以及 IDEA配置Maven環(huán)境》，本文的上一篇為《純注解開發(fā)模式下的依賴注入和讀取properties配置文件》前面定義bean的時
2024年02月04日
瀏覽(29)
【Spring教程十】Spring框架實戰(zhàn)：全面深入詳解IOC/DI之--純注解開發(fā)模式下的依賴注入&&注解讀取properties配置文件
歡迎大家回到《 Java教程之Spring30天快速入門》，本教程所有示例均基于Maven實現(xiàn)，如果您對Maven還很陌生，請移步本人的博文《如何在windows11下安裝Maven并配置以及 IDEA配置Maven環(huán)境》，本文的上一篇為《全面深入詳解IOC/DI注解開發(fā)》 Spring為了使用注解簡化開發(fā)，并沒有提供
2024年02月04日
瀏覽(25)
129.【Spring 注解_IOC】
(1).無注解注入方式在pom文件中加入spring-context依賴: xml文件和注解的包定義一個實體類在resource目錄下的beans.xml配置文件中通過 bean /bean標(biāo)簽注入類實例獲取容器中通過配置文件注入的實例對象 (2).注解注入方式 1.MyConfig.java 2.Main.java (1).無注解掃描方式只要我們加上 @Config
2024年02月12日
瀏覽(20)
Spring IOC相關(guān)注解運用——下篇
目錄一、@Configuration 二、@ComponentScan 1. 說明 2. 測試方法 3. 運行結(jié)果三、@PropertySource 1. 說明 2. 測試方法 3. 測試結(jié)果四、@Bean 1. 說明 2. 添加驅(qū)動依賴 3.?將Connection對象放入Spring容器 3. 測試五、@Import 1. 說明 2. 測試方法 3. 運行結(jié)果往期專欄文章相關(guān)導(dǎo)讀? 1. Maven系列專欄文
2024年02月05日
瀏覽(21)
Spring IOC相關(guān)注解運用——上篇
目錄前言一、@Component 二、@Repository、@Service、@Controller 三、@Scope 四、@Autowired 五、@Qualifier 六、@Value 1. 直接設(shè)置固定的屬性值 2.?獲取配置文件中的屬性值 3. 測試結(jié)果往期專欄文章相關(guān)導(dǎo)讀? 1. Maven系列專欄文章 2. Mybatis系列專欄文章 3. Spring系列專欄文章 ????????注解配
2024年02月02日
瀏覽(24)
Spring IOC @Configuration注解分析
在使用SpringBoot開發(fā)時，最常用的注解有@Component、@Service、@Controller、@Configuration等。當(dāng)類使用這些注解標(biāo)記時，類會被Spring IOC容器管理，包括創(chuàng)建，填充屬性和實例化。但是Spring容器如何發(fā)現(xiàn)并將這些類放到容器進行管理呢？今天這篇博客主要分析Spring如何處理@Configuratio
2024年02月08日
瀏覽(18)
javaee spring 用注解的方式實現(xiàn)ioc
spring核心依賴 spring配置文件
2024年02月10日
瀏覽(26)

<xmp id="bidem"><mark id="bidem"></mark>