Java之Spring基礎與IoC

CoLoo發表於2021-08-26
JavaSpring

Spring

About Spring

開源免費框架，輕量級，非入侵式框架。Spring就是一個輕量級的控制反轉（IOC）和麵向切片程式設計（AOP）的框架

Maven repo：Spring Web MVC + spring-jdbc(整合Mybatis)

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.9</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.9</version>
</dependency>

Spring兩大特點

控制反轉（IOC）

面向切片程式設計（AOP）支援事務處理

Spring

About IOC

控制反轉：IOC是一種設計思想，通過描述（XML或註解）並通過第三方生產或獲取物件的方式。之前物件的建立與物件的依賴關係完全在java硬編碼程式中，控制權在程式；實現IOC後，控制權在第三方，實現降藕。

在Spring中實現控制反轉的是IoC容器，實現方法是依賴注入DI（Dependency Injection,DI）

引用狂神的一個例子簡單理解下

private UserDao userDao = null;

public UserServiceImpl(){
    userDao = new UserDaoImpl();
}

在之前我們使用JavaWeb寫service=>dao的時候，是通過如上的方式去實現的，專案構建大概如下

那麼如果此時我的UserDao介面又了一個新的實現類暫且為UserDaoImpls，這個實現類中有新的功能實現，那麼就需要到UserServiceImpl中再去構造方法加一段如下的程式碼：

userDao = new UserDaoImpls();

那麼這時如果該專案還沒釋出那到無所謂，如果是已經上線的專案是不可能這樣重新去修改程式碼的，或者如果有n個new，就要修改n處。

解決這個問題就是通過一個set方法。如下：

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

在構造方法中例項化物件的這個操作，改為利用set封裝並將需要new的實現類的名稱變為set方法的引數，實現使用者可控的去new一個新的實現類從而新增新的功能展示到頁面。

而這個思想就是控制反轉（IOC）的原型，將new實現類物件的主動權交給了使用者而不是程式，從本質上解決了上面的問題，也實現了降藕。

Hello Spring

Hello.java

package com.zh1z3ven.pojo;

public class Hello {
    private String str;

    public Hello() {
    }

    public Hello(String str) {
        this.str = str;
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

Beans.xml

一個bean標籤代表一個物件， id代表在Spring中這個類要例項化生成的物件的名字， class指定這個實體類

設定物件的屬性值

引用Spring容器中建立的物件

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--使用Spring建立物件，Spring都稱之為bean-->
<!--    一個bean標籤代表一個物件， id代表要例項化的物件的名字， class指定這個實體類-->
    <bean id="hello" class="com.zh1z3ven.pojo.Hello">
<!--        設定實體類的屬性值-->
        <property name="str" value="Spring"/>
    </bean>
</beans>

Test.java

在Spring中也存在一個上下文，通過ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");傳入xml配置檔名字來獲取該xml檔案的上下文物件。利用ApplicationContext#getBean()傳入在xml中配置的該類的id獲取該實體類物件。

public class MyTest {
    public static void main(String[] args) {

        //獲取Spring上下文物件
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //從Spring中取出物件
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);

    }
}

IOC建立物件的幾種方式

PS:在配置檔案載入的時候，通過bean標籤註冊的物件就已經在Spring IoC容器中初始化了。

總體來說就兩種方式：

  • 無參構造

    預設使用

  • 有參構造

    1. 下標賦值

      <!--通過下標賦值-->
<bean id="hello2" class="com.zh1z3ven.pojo.Hello">
    <constructor-arg index="0" value="Spring2"/>
</bean>

    2. 型別複製

      <!--通過型別賦值-->
<bean id="hello3" class="com.zh1z3ven.pojo.Hello">
    <constructor-arg type="java.lang.String" value="Spring3"/>
</bean>

    3. 屬性名賦值

      <!--屬性名賦值-->
<bean id="hello4" class="com.zh1z3ven.pojo.Hello">
    <constructor-arg name="str" value="Spring4"/>
</bean>

Spring import settings

import標籤可匯入其他beans.xml配置檔案，而applicationContext.xml到時可作為總bean的配置檔案，而不需要匯入多個xml

Dependency Injection

依賴注入（Dependency Injection，DI）

PS：一定需要pojo中實現set才可以利用bean標籤注入

  1. 構造器注入

    也就是上面提到的建立物件的方式，分為無參構造和有參構造

    • 無參構造

      預設使用

    • 有參構造

      1. 下標賦值

        <!--通過下標賦值-->
<bean id="hello2" class="com.zh1z3ven.pojo.Hello">
    <constructor-arg index="0" value="Spring2"/>
</bean>

      2. 型別複製

        <!--通過型別賦值-->
<bean id="hello3" class="com.zh1z3ven.pojo.Hello">
    <constructor-arg type="java.lang.String" value="Spring3"/>
</bean>

      3. 屬性名賦值

        <!--屬性名賦值-->
<bean id="hello4" class="com.zh1z3ven.pojo.Hello">
    <constructor-arg name="str" value="Spring4"/>
</bean>

  2. set注入

    依賴：bean物件的注入依賴於Spring容器

    注入：bean物件的屬性，由容器來注入

  3. 擴充注入

    Student.java

    public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private String apache;
    private Properties info;

    public String getApache() {
        return apache;
    }

    public void setApache(String apache) {
        this.apache = apache;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbys() {
        return hobbys;
    }

    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbys=" + hobbys +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

    beans.xml

    <bean id="address" class="com.zh1z3ven.pojo.Address">
    <property name="address" value="beijing"/>
</bean>
<bean id="student1" class="com.zh1z3ven.pojo.Student">
<!--        普通屬性值注入-->
    <property name="name" value="zh1z3ven"/>

<!--        ref 引用物件注入-->
    <property name="address" ref="address"/>

<!--        陣列array注入-->
    <property name="books">
        <array>
            <value>紅樓夢</value>
            <value>西遊記</value>
            <value>水滸傳</value>
            <value>三國演義</value>
        </array>
    </property>

<!--        List注入-->
    <property name="hobbys">
        <list>
            <value>聽音樂</value>
            <value>看電影</value>
            <value>敲程式碼</value>
            <value>寫文章</value>
        </list>
    </property>

<!--        Map注入-->
    <property name="card">
        <map>
            <entry key="銀行卡" value="1"></entry>
            <entry key="身份證" value="2"></entry>
            <entry key="學生證" value="3"></entry>
            <entry key="電話卡" value="4"></entry>
            <entry key="校園卡" value="5"></entry>
        </map>
    </property>

<!--        Set注入-->
    <property name="games">
        <set>
            <value>LOL</value>
            <value>CF</value>
            <value>qq</value>
        </set>
    </property>

<!--        null注入-->
    <property name="wife">
        <null></null>
    </property>

<!--        空值注入-->
    <property name="apache" value=""/>

<!--        properties-->
    <property name="info">
        <props>
            <prop key="id">10</prop>
            <prop key="city">北京</prop>
        </props>
    </property>
</bean>

P-namespcae&C-namespace

  1. p名稱空間注入，可以直接注入屬性值，類似於bean標籤中property-name-value

    Beans.xml頭部需匯入

    xmlns:p="http://www.springframework.org/schema/p"

    <bean id="user1" class="com.zh1z3ven.pojo.User" p:name="zh1z3ven1" p:age="18"/>

  2. c名稱空間注入，通過構造器注入，類似於construct-args(需要實現有參構造)

    xmlns:c="http://www.springframework.org/schema/c"

    <bean id="user2" class="com.zh1z3ven.pojo.User" c:name="zh1z3ven2" p:age="19"/>

@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User user1 = context.getBean("user1", User.class);
    System.out.println(user1.getName());
    System.out.println(user1.getAge());

    User user2 = context.getBean("user2", User.class);
    System.out.println(user2.getName());
    System.out.println(user2.getAge());
}

Bean scopes

bean的作用域

singleton

預設bean為scope = singleton單例模式執行的

顯示定義：<bean id="user1" class="com.zh1z3ven.pojo.User" p:name="zh1z3ven1" p:age="18" scope="singleton"/>

單例模式，共享一個物件,比如如下例子,getBean指向的是同一個bean，那麼在Spring IoC容器中僅僅會生成一個"user2"物件儲存在記憶體中，當呼叫ApplicationContext.getBean("user2")時返回該物件

<bean id="user2" class="com.zh1z3ven.pojo.User" c:name="zh1z3ven2" c:age="19"/>

@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User user1 = context.getBean("user2", User.class);
    User user2 = context.getBean("user2", User.class);
    System.out.println(user1==user2);
}

prototype

原型模式prototype與singleton不同，每次上下文去getBean()時都會在Spring IoC容器內建立一次該物件

還是拿上面的測試程式碼，可以發現已經不是同一個物件了，有點類似於多型

public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user1 = context.getBean("user2", User.class);
        User user2 = context.getBean("user2", User.class);
        System.out.println(user1==user2);
    }

而其餘的生命週期在Web中才會遇到。

Bean的自動裝配

  • 在xml顯示配置bean
  • 在java程式碼中配置bean
  • 隱式自動裝配bean【autowire】

byName autowire

會在容器上下文中自動查詢，和自己物件set方法後面的值對應的beanid。也就是這裡會去上下文中尋找有無"cat"這個beanid，有則自動裝配，如果並沒有匹配上，比如此時beanid被修改為了"cat123" 就會跑出異常。

byType autowire

會在容器上下文中尋找該型別與屬性值所對應的型別相同的bean，基於bean中的class（需要在上下文中所有型別各自只出現一次）

<bean id="people" class="com.zh1z3ven.pojo.People" autowire="byType">
    <property name="name" value="zh1z3ven"/>
</bean>

小結

  • byname需要保證所有bean的id唯一，且這個bean的id的值要和需要自動裝配依賴注入的set方法的值一致。
  • bytype需要保證所有bean的class唯一，且這個bean的class的值需要和set方法的值的型別一致。

註解實現自動裝配

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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

@Autowired

預設使用byname方式去自動裝配，它可以對類成員變數、方法及建構函式進行標註，完成自動裝配的工作。

在使用@Autowired時，首先在容器中查詢對應型別的bean（bytype）

如果查詢結果剛好為一個，就將該bean裝配給@Autowired指定的資料

如果查詢的結果不止一個，那麼@Autowired會根據名稱來查詢。（byname）

如果查詢的結果為空，那麼會丟擲異常。解決方法時，使用@Autowried(required=false)

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;

@Qualifier

如果存在多個型別且該型別有多個不同名字的物件，那麼只用@Autowired會找不到該物件，可以配合@Qualifier(value="")來指定一個裝配的值。

@Autowired
@Qualifier(value="dog222")

@Resource

java自帶的一個註解，和@Autowired，@Qualifier組合用法和效果基本是一樣

javax.annotation.Resource
@Resource //不指定名稱自動裝配
@Resource(name="") //指定名稱自動裝配

使用註解開發

bean在xml裡註冊，屬性值通過註解注入

@component

泛指各種元件，把普通pojo例項化到spring容器中,相當於配置檔案中的bean,將該類在配置檔案下注冊到Spring容器中裝配bean。類似的還有：

1、@controller 控制器（注入服務）
用於標註控制層，相當於struts中的action層

2、@service 服務（注入dao）
用於標註服務層，主要用來進行業務的邏輯處理

3、@repository（實現dao訪問）
用於標註資料訪問層，也可以說用於標註資料訪問元件，即DAO元件.

@Scope

生命週期,用法：在目標類上面宣告

@Scope("singleton")

@Configuration

用於宣告這是一個配置類

@Bean

相當於在配置檔案中註冊bean

方法名為之前的id屬性

方法返回值為之前的class屬性

@Import

匯入其他配置類，等價於

<import resource="beans.xml"/>

使用方法

@Import(Config.class)

示例程式碼

pojo

//相當於在bean中註冊,相當於在Spring IoC容器new一個物件
@Component
public class User {
    @Value("CoLoo")
    public String name;

    public String getName() {
        return name;
    }

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

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

config

@Configuration
@ComponentScan("com.zh1z3ven.pojo")
public class AppConfig {
    @Bean
    public User getUser(){
        return new User();
    }
}

test

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        User user = context.getBean("user", User.class);
        System.out.println(user.getName());
    }
}

相關文章