2021最新Spring教程（精簡）

本文轉載自查看原文 2021-08-29 12:22 90 Java/ 2021/ Spring/ 框架/ 計算機

一、spring文件及注解
三、引入其他配置文件（分模塊開發）
- 1、< import >標簽
四、Spring的重點配置
- 1、< property >標簽：屬性注入、setter()
- 2、< constructor-arg >標簽：指定構造函數的參數注入
五、SpringAPI
六、配置數據源
七、Spring配置數據源：DataSource——.set方法注入
- 1、application配置文件：配置連接信息——com.mchange.v2.c3p0.ComboPooledDataSource
  - 1.注意一個問題：&會報錯——寫成&
- 2、代替ComboPooledDataSource——>ClassPathXmlApplicationContext
八、Spring單獨配置數據源：xml加載properties文件——分開數據庫與Spring
- 1、spring加載properties文件步驟：
九、Spring注解開發

一、spring文件及注解

1、spring配置主要全部文件

在這里插入圖片描述

pom.xml

 	 <dependencies>
        <!--————————————————添加Spring依賴支持————————————————-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>5.3.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.3.7</version>
        </dependency>
        <!--————————————————添加Spring測試支持————————————————-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.7</version>
        </dependency>
        <!--————————————————添加Spring-MVC視圖表現層支持————————————————-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.7</version>
        </dependency>
        <!--————————————————添加Spring 數據庫事務管理支持————————————————-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.3.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.7</version>
        </dependency>
        <!--————————————————添加Spring-aop面向切面編程支持————————————————-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.3.7</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.7</version>
        </dependency>
    </dependencies>

applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
		http://www.springframework.org/schema/mvc
		http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context-3.2.xsd
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
		http://www.springframework.org/schema/tx
		http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">


    <bean id="userDao"  class="com.remli.dao.impl.UserDaoImpl"></bean>

    
</beans>

Main.java

    public static void main(String[] args) {
        /*解析application.xml配置文件獲取Bean實例(對象)*/
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        /*對象獲取並強制轉換類型*/
        UserDao userDao = (UserDao) app.getBean("userDao");
        /*對象調用方法*/
        userDao.save();
    }

        /*獲取文件流*/
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        /*接口*/                      /*接口實現*/

        /*獲取對象*/                /*強轉對象*/
        UserService userService = (UserService) app.getBean("userService");

        userService.save();

UserDao.java


public interface UserDao {
    /*接口的方法*/
    public void save();
}

UserDaoImpl.java

public class UserDaoImpl implements UserDao {
    /*實現接口的類的方法*/
    public void save() {
        System.out.println("程序啟動");
    }
}

2、spring配置主要全部注解

3、Spring重點基礎知識

1.名詞解釋

類（人類）：共同特征的實體的集合、模板、一類事物、抽象、概念、同種屬性

實例：一個真實的對象

對象（個人）：組成類的元素、類的具體實現、實際執行者

屬性：數據（變量/值）

定義：編譯器創建對象、分配內存、取名(變量名/對象名)

聲明：聲明對象(對象名/對象類型)、告知編譯器對象/屬性的情況

實例化：類創建對象的過程

初始化：為變量分配內存空間、並確定其初始值的過程

構造方法：與類同名的特殊方法、創建對象

構造器：與類同名的特殊方法、創建對象

2.Bean生命周期：1實例化、2屬性賦值、3初始化、4使用、5銷毀

實例化前階段：執行Instantiation Aware Bean PostProcessor Adapter的post Process Before ln station方法

執行Instantiation Aware Bean PostProcessor Adapter的determine Candidate Constructors方法

接口Merged Bean Definition PostProcessor的post Process Merged Bean Definition方法

實例化Bean(執行Bean構造方法)

實例化后階段：執行Instantiation Aware Bean PostProcessor Adapter的post Process After In station方法。方法返回false的時候，后續的Bean屬性賦值前處理、Bean屬性賦值都會被跳過了，

屬性賦值前階段(可在此修改屬性的值)：執行Instantiation Aware Bean PostProcessor的post Process Properties方法。返回空的時候，表示這個bean不需要設置屬性，直接返回了，直接進入下一個階段。

屬性賦值(Populate)

Aware接口

執行Instantiation Aware Bean PostProcessor Adapte的post Process Before ln it i alization方法

自定義初始化方法

執行Instantiation Aware Bean PostProcessor Adapte的post Process After ln it i alization方法

容器創建成功，提供使用

調用自定義銷毀方法方法

3.Bean 標簽屬性

id 屬性：唯一性、不可重復
屬性值任意命名，但不可以包含中文以及特殊字符。
根據 id 屬性值得到配置對象。
class 屬性：類的全路徑名稱
創建對象所在類的全路徑名稱。
name 屬性：不可重復
功能和 id 一致。已基本不用。
區別： id 屬性值不可以包含特殊字符， name 屬性值可以包含。
scope 屬性
bean 作用范圍屬性值：

取值范圍
singleton 單例	默認值、只生成1個實例
prototype 多例	多例的
request	WEB項目中， Spring創建一個Bean的對象，將對象存入到request域中
session	WEB項目中， Spring創建一個Bean的對象，將對象存入到session域中
global session	WEB項目中，應用在Portlet環境，如果沒有Portlet環境那么global Session相當於session

作用域：scope

 singleton: 單例模式，在整個Spring IoC容器中，singleton作用域的Bean將只生成一個實例。
 prototype: 每次通過容器的getBean()方法獲取prototype作用域的Bean時，都將產生一個新的Bean實例。
 request: 對於一次HTTP請求，request作用域的Bean將只生成一個實例，這意味着，在同一次HTTP請求內，程序每次請求該Bean，得到的總是同一個實例。只有在Web應用中使用Spring時，該作用域才真正有效。
 session：該作用域將 bean 的定義限制為 HTTP 會話。 只在web-aware Spring ApplicationContext的上下文中有效。
 global session: 每個全局的HTTP Session對應一個Bean實例。在典型的情況下，僅在使用portlet context的時候有效，同樣只在Web應用中有效。

4.Spring核心：

Spring容器接口：ApplicationContext

 ClassPathXmlApplicationContext: 從類加載路徑下搜索配置文件，並根據配置文件來創建Spring容器。
 FileSystemXmlApplicationContext: 從文件系統的相對路徑或絕對路徑下去搜索配置文件，並根據配置文件來創建Spring容器。

4、bean實例化：無參、工廠靜態、工廠實例

1.無參構造方法實例化：默認

    <!--找無參構造方法-->
    <bean id="userDao"  class="com.remli.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy" scope="prototype"></bean>

/*重寫無參構造——修改默認構造方法——對應接口*/
public UserDaoImpl(){
    System.out.println("無參構造修改：UserDaoImpl對象創建...");
}

2.工廠靜態方法實例化：直接調用方法

 	<!--找全包名對應內部指定的方法、去返回對應的對象-->
    <bean id="userDao1"  class="com.remli.factory.StaticFactory" scope="prototype" factory-method="getUserDao"></bean>

public class StaticFactory {
    /*對象工廠——對象創建——返回對象*/
    public static UserDao getUserDao() {
        /*返回對象*/
        return new UserDaoImpl();
    }
}

3.工廠實例方法實例化：先有工廠對象再調方法

 	<!--先創建工廠對象-->
    <bean id="factory"  class="com.remli.factory.DynamicFactory" scope="prototype" ></bean>
    <!--從容器當中工廠對象內部的方法獲取指定返回的對象-->
    <bean id="userDao2"  factory-bean="factory" factory-method="getUserDao"></bean>

public class DynamicFactory {
    /*對象工廠*/
    public UserDao getUserDao() {
        /*返回對象*/
        return new UserDaoImpl();
    }
}

5、依賴注入DI：注入類型：對象、普通數據、集合數據

1.構造方法注入：有參構造

    <bean id="userService"  class="com.remli.service.impl.UserServiceImpl">
                    <!--參數名-->            <!---->
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>

    public UserServiceImpl(UserDao userDao) {/*有參構造*/
        this.userDao = userDao;
    }

2.set方法注入：

    <!--找無參構造方法-->
    <bean id="userDao"  class="com.remli.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy" scope="prototype"></bean>

    <!--set依賴注入-->
    <bean id="userService"  class="com.remli.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>

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

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

3.p命名空間注入：(本質set)

1引入p命名空間：

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

2修改注入方式：

    <bean id="userService"  class="com.remli.service.impl.UserServiceImpl" p:userDao-ref="userDao" />

6、依賴注入類型：引用數據(對象)、普通數據、集合數據

1.普通數據

    private String username;
    private int age;


    public void setUsername(String username) {
        this.username = username;
    }

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

    <bean id="userDao11"  class="com.remli.dao.impl.UserDaoImpl" >
        <!--屬性注入-->
        <property name="username" value="注意空格"/>
        <property name="age" value="2021825"/>
    </bean>

        /*獲取文件流*/
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        /*接口*/      /*接口實現*/
        UserDao ud = (UserDao) app.getBean("userDao11");
       /*獲取對象*/  /*強轉對象*/
       
        Object ud1 = app.getBean("userDao11");
        
        ud.save();

2.引用數據

3.集合數據

	/*定義變量、構造方法*/
    private List<String> strList;
    private Map<String , User> userMap;
    private Properties properties;

    public void setStrList(List<String> strList) {
        this.strList = strList;
    }

    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }


   	/*實現接口的類的方法*/
    public void save() {
        System.out.println(strList);
        System.out.println(userMap);
        System.out.println(properties);
    }

    private String name;
    private String addr;

    public String getName() {
        return name;
    }

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

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

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

    <bean id="userDao222"  class="com.remli.dao.impl.UserDaoImpl" >
        <!--屬性注入-->
        <property name="strList">
            <list>
                <value>任</value>
                <value>明</value>
                <value>任</value>
            </list>
        </property>
        <property name="userMap">
            <map><!--key value-->
                <entry key="key1" value-ref="user11"> </entry>
                <entry key="key2" value-ref="user22"> </entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="1">111</prop>
                <prop key="2">1112</prop>
                <prop key="3">1113</prop>
            </props>
        </property>
    </bean>

    <bean id="user11" class="com.remli.domain.User">
        <property name="name" value="我是"></property>
        <property name="addr" value="中國"></property>
    </bean>
    <bean id="user22" class="com.remli.domain.User">
        <property name="name" value="我是1"></property>
        <property name="addr" value="中國1"></property>
    </bean>

        /*獲取文件流*/
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        /*接口*/      /*接口實現*/
        UserDao u2= (UserDao) app.getBean("userDao222");
       /*獲取對象*/  /*強轉對象*/
       
        Object d2 = app.getBean("userDao222");

        u2.save();

三、引入其他配置文件（分模塊開發）

實際開發中，Spring的配置內容非常多，這導致Spring配置很繁雜，使用可以拆分到其它配置文件當
中，而且Spring主配置文件通過import標簽加載

1、< import >標簽

  <!--主配置文件——引入分模塊文件-->
    <import resource="applicationContext-user.xml"></import>

applicationContext.xml
applicationContext-product.xml
applicationContext-user.xml

四、Spring的重點配置

1、< property >標簽：屬性注入、setter()

property：通過setter對應的方法注入。

<property>標簽：屬性注入
	name屬性：屬性名稱
	value屬性：注入的普通屬性值
	ref屬性：注入的對象引用值
	<list>標簽
	<map>標簽
	<properties>標簽

1. name屬性：屬性名稱

1. value屬性：注入的普通屬性值

1. ref屬性：注入的對象引用值

1. < set >標簽：集合——引用ref

<!-- 給set注入值 不能有相同的對象 -->

<property name="empSets">
	<set>
		<ref bean="emp1" />
		<ref bean="emp2"/>
	</set>
</property>

1. < list >標簽：集合——引用ref

<!-- 給list注入值 可以有相同的多個對象 -->

	   <property name="strList">
	      <list>
	            <value>人</value>
	            <value>民</value>
	            <value>人</value>
	       </list>
	   </property>

1. < map >標簽：集合——鍵值對

<!-- 給map注入值 只要map中的key值不一樣就可以裝配value -->

        <property name="userMap">
            <map><!--key value-->
                <entry key="key1" value-ref="user11"> </entry>
                <entry key="key2" value-ref="user22"> </entry>
            </map>
        </property>

1. < properties >標簽：與map類似——鍵值對

        <property name="properties">
            <props>
                <prop key="1">111</prop>
                <prop key="2">1112</prop>
                <prop key="3">1113</prop>
            </props>
        </property>

2、< constructor-arg >標簽：指定構造函數的參數注入

constructor-arg：通過構造函數注入。

    <!--找無參構造方法-->
    <bean id="userDao"  class="com.remli.dao.impl.UserDaoImpl">
    </bean>

    <bean id="userService"  class="com.remli.service.impl.UserServiceImpl">
                    <!--參數名-->            <!---->
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>

constructor-arg屬性通過指定type 類型來調用對應的構造函數，


    <constructor-arg name="id" value="1"/>
    
    <constructor-arg name="name" value="student"/>
    
    <constructor-arg name="dream">
        <list>
            <value>soldier</value>
            <value>scientist</value>
            <value>pilot</value>
        </list>
    </constructor-arg>
    
    <constructor-arg name="score">
        <map>
            <entry key="math" value="90"/>
            <entry key="english" value="85"/>
        </map>
    </constructor-arg>

五、SpringAPI

1、ApplicationContext的繼承

applicationContext:接口類型，代表應用上下文，可通過其實例獲得Spring容器中的Bean對象。

2、ApplicationContext的實現類

1.ClassPathXmlApplicationContext：類路徑文件類型應用上下文——resource下文件(相對)

它是從類的根路徑下加載配置文件（常用）

        /*獲取文件流*/
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        /*接口*/                      /*接口實現*/

2.FileSystemXmlApplicationContext：文件系統文件類型應用上下文——磁盤絕對路徑

它是從磁盤路徑上加載配置文件，配置文件可以在磁盤的任何位置。

ApplicationContext appp = new FileSystemXmlApplicationContext("C:\\Users\\REMLI\\IdeaProjects\\REM_SSMS\\src\\main\\resources\\applicationContext.xml");

3.AnnotationConfigApplicationContext：注解配置應用上下文——注解開發

當使用注解配置容器對象時，需要使用此類來創建Spring容器。它用來讀取注解。

3、getBean()方法的使用

1.強轉類型

一個是通過id來獲取：某一個類型可存在多個，獲取后需要強轉。

        UserDao u111= (UserDao) appp.getBean("userDao222");

2.直接獲取類對象：類文件直接指定

一個通過返回值來獲取：一種類型只能有一個，獲取后不需要強轉。

        UserDao userDao = app.getBean(UserDao.class);

3.通過java對象獲取

        Object d111 = appp.getBean("userDao222");

六、配置數據源

1 、數據源（連接池）的作用

1.提高程序性能

2.事先實例化數據源、初始化部分連接資

3.使用連接資源時從數據源中獲取

4.使用完畢后將連接資源歸還給數據源

常見數據源：DBCP，C3P0，BoneCP、Druid等

2 、引入相關坐標依賴

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>5.3.7</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.19</version>
    </dependency>
    <!--添加Druid依賴-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.10</version>
    </dependency>
    <dependency>
        <groupId>c3p0</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.1.2</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

3、手動創建C3P0數據源：一定要注意空格、注意名稱正確

    @Test
    /*測試手動創建c3p0數據源*/
    public void test1() throws Exception {
        /*創建數據源*/
        /*康波坡爾*/
        /*注意一個問題保證mysql語句的正確、Mysql 8.0.19和以前版本連接語句略微不同*/
        /*實例化對象*/
        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        /*對象調用方法——並set方法賦值*/
        /*賦值驅動類數據庫連接信息*/
        dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/remli?useSSL=false&serverTimezone=UTC");
        dataSource.setUser("root");
        dataSource.setPassword("2020");
        
        /*創建對象獲取連接信息*/
        Connection connection = dataSource.getConnection();
        
        /*打印對象信息*/
        System.out.println("\n地址："+connection);
        
        /*連接關閉、歸還資源*/
        connection.close();

    }

4、手動創建Druid數據源：一定要注意空格、注意名稱正確

    @Test
    /*測試手動創建druid數據源*/
    /*如果找不到DruidDataSource請在maven里清理clean里面的jar包*/
    public void test2() throws Exception {
        /*創建數據源*/
        /*注意一個問題保證mysql語句的正確、Mysql 8.0.19和以前版本連接語句略微不同*/
        /*實例化對象*/
        DruidDataSource dataSource = new DruidDataSource();
        
        /*對象調用方法——並set方法賦值*/
        /*賦值驅動類數據庫連接信息*/
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");/*存在耦合*/
        dataSource.setUrl("jdbc:mysql://localhost:3306/remli?useSSL=false&serverTimezone=UTC");/*存在耦合*/
        dataSource.setUsername("root");/*存在耦合*/
        dataSource.setPassword("2020");/*存在耦合*/
        
        /*創建對象獲取連接信息*/
        DruidPooledConnection connection = dataSource.getConnection();
       
        /*打印對象信息*/
        System.out.println(connection);
        
        /*連接關閉、歸還資源*/
        connection.close();
    }

5、手建C3P0(加載properties配置文件)：注意空格、名稱正確

1.創建代碼：

    @Test
    /*測試手動創建c3p0數據源(加載properties配置文件)*/
    public void test3() throws Exception {
    
        /*讀取配置文件*/
        ResourceBundle rb = ResourceBundle.getBundle("jdbc");
        String driver = rb.getString("jdbc.driver");
        String url = rb.getString("jdbc.url");
        String username = rb.getString("jdbc.username");
        String password = rb.getString("jdbc.password");

        /*創建數據源對象、設置連接參數*/
        /*康波坡爾*/
        /*注意一個問題保證mysql語句的正確、Mysql 8.0.19和以前版本連接語句略微不同*/
        /*實例化對象*/
        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        /*對象調用方法——並set方法賦值*/
        /*賦值驅動類數據庫連接信息*/
        /*注意值不能加雙引號*/
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);

        /*創建對象獲取連接信息*/
        Connection connection = dataSource.getConnection();

        /*打印對象信息*/
        System.out.println("\n地址："+connection);

        /*連接關閉、歸還資源*/
        connection.close();

    }

2.配置文件jdbc.properties：注意語句正確、空格、名稱

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/remli?useSSL=false&serverTimezone=UTC
jdbc.username=root
jdbc.password=2020

七、Spring配置數據源：DataSource——.set方法注入

將DataSource創建權——交給Spring容器完成
DataSource有無參構造方法——Spring默認通過無參構造方法實例化對象
使用DataSource獲取數據庫的連接對象——需通過set方法設置數據庫連接信息——Spring可通過set方法進行字符串注入

1、application配置文件：配置連接信息——com.mchange.v2.c3p0.ComboPooledDataSource

1.注意一個問題：&會報錯——寫成&amp

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--set方法注入參數-->
		<!--這里的名稱是java里面的首字母小寫-->
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/remli?useSSL=false&amp;serverTimezone=UTC"></property>
        <property name="user" value="root"></property>
        <property name="password" value="2020"></property>
    </bean>

2、代替ComboPooledDataSource——>ClassPathXmlApplicationContext

    @Test
    /*測試Spring容器產生數據源對象(加載application.xml配置文件)*/
    public void test4() throws Exception {
        /*讀取配置文件*/
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        /*創建數據源對象、設置連接參數*/
        /*實例化對象*/
        DataSource dataSource4 = app.getBean(DataSource.class);

        /*創建對象獲取連接信息*/
        Connection connection4 = dataSource4.getConnection();

        /*打印對象信息*/
        System.out.println("\n地址："+connection4);

        /*連接關閉、歸還資源*/
        connection4.close();

    }

八、Spring單獨配置數據源：xml加載properties文件——分開數據庫與Spring

properties的鍵值對寫法需要注意不要有鍵名相同！！！
各自的數據庫——加載——對應properties文件

1、spring加載properties文件步驟：

1.引入context命名空間和約束路徑：

applicationContext.xml加載jdbc.properties配置文件——獲得連接信息
首先引入context命名空間和約束路徑：

1命名空間：xmlns:context="http://www.springframework.org/schema/context"

context命名空間中有組件掃描和加載外部.properties文件的標簽
加載到IOC中的.properties文件可以通過spring el表達式獲取,格式為:${鍵名}

<context:component-scan />:配置組件掃描,可以掃描指定包下的注解
<context:property-placeholder />:加載外部的.properties文件到spring容器當中,
可以通過spel,即${}獲取到值,例如配置數據庫連接參數

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

2約束路徑：http://www.springframework.org/schema/context

約束路徑1：http://www.springframework.org/schema/context                      
約束路徑2：http://www.springframework.org/schema/context/spring-context.xsd

spring啟動時需驗證xml文檔,約束的作用就是來驗證配置文件的xml文檔語法的正確性。

		http://www.springframework.org/schema/context/spring-context.xsd

2.加載配置文件標簽：< context:property-placeholder location="xx.properties"/ >

<context:property-placeholder />:加載外部的.properties文件到spring容器當中,
可以通過spel,即${}獲取到值,例如配置數據庫連接參數

    <!--加載外部properties配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

3.< property name="" value="${key}"/ >：spr語言——EL

獲取key值——獲取properties對應名稱值

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--set方法注入參數-->
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

4.DataSource.class

    <!--解耦合-->
    <!--這個地方可以更換數據源-->
    <!--加載外部properties配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--set方法注入參數-->
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    @Test
    /*測試Spring容器產生數據源對象(加載application.xml配置文件)*/
    public void test4() throws Exception {
        /*讀取配置文件*/
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        /*創建數據源對象、設置連接參數*/
        /*實例化對象*/
        DataSource dataSource4 = app.getBean(DataSource.class);

        /*創建對象獲取連接信息*/
        Connection connection4 = dataSource4.getConnection();

        /*打印對象信息*/
        System.out.println("\n地址4："+connection4);

        /*連接關閉、歸還資源*/
        connection4.close();

    }

5.DruidDataSource.class

    <!--解耦合-->
    <!--這個地方可以更換數據源-->
    <!--加載外部properties配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!--set方法注入參數-->
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    @Test
    /*測試Spring容器產生數據源對象(加載application.xml配置文件)*/
    public void test5() throws Exception {
        /*讀取配置文件*/
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        /*創建數據源對象、設置連接參數*/
        /*實例化對象*/
        DruidDataSource dr = app.getBean(DruidDataSource.class);

        /*創建對象獲取連接信息*/
        Connection connection5 = dr.getConnection();

        /*打印對象信息*/
        System.out.println("\n地址5："+connection5);

        /*連接關閉、歸還資源*/
        connection5.close();

    }

2者不能同時開啟、會相互報錯

總結：命名空間修改方法，賦值xmlns后的url，將beans改為context，然后建立新的xmlns:context。
復制前一段xsi：schemaLocation將所有的beans都改為context添加在后面。
引入文件路徑，classpath表示class文件路徑，resource文件默認保存在classpath文件下，
所以路徑為"classpath:jdbc.properties"。
在xml中調用properties文件，使用EL表達式。

問題記錄：
	導入properties后，Druid報錯：
		[create connection SQLException, 
		url:jdbc:mysql://localhost:3306/demo, errorCode 1045, state 28000]

錯誤原因：properties配置文件中的名字與Driud屬性名沖突。

修改前：
	driver=com.mysql.cj.jdbc.Driver
	url=jdbc:mysql://localhost:3306/remli?useSSL=false&serverTimezone=UTC
	username=root
	password=2020

修改后：
	jdbc.driver=com.mysql.cj.jdbc.Driver
	jdbc.url=jdbc:mysql://localhost:3306/remli?useSSL=false&serverTimezone=UTC
	jdbc.username=root
	jdbc.password=2020

九、Spring注解開發

語義化：見名知意

1、 Spring原始注解

Spring原始配置主要替代<Bean>的配置

@Component——id——實例化——隨便那個——無語義

使用在類上用於實例化Bean
該組件用於Spring生成一個bean——>Component:組件
Component:組件 ByID

@Component("userDao")/*相當於配置文件id、定位類*/

@Component("userService")/*相當於配置文件id、定位類*/

@Controller——Web層控制類實例化——語義化

使用在web層類上用於實例化Bean
該控制器用於Spring生成一個bean

@Service——Service層服務類實例化——語義化

使用在service層類上用於實例化Bean
該業務邏輯類用於Spring生成一個bean

@Service("userService")/*相當於配置文件id、定位類*/

@Repository——id——Dao層數據存儲類實例化——語義化

使用在dao層類上用於實例化Bean
該Dao類用於Spring生成一個bean——>repository:貯藏室 數據封裝基地
Repository:貯藏室 ByID

@Repository("userDao")/*相當於配置文件id、定位類*/

@Controller
@Service
@Repository
@Component
4者無本質區別
他們存在是為區分開web、service、dao層
方便代碼閱讀。

@Autowired——無需Setter——字段按類型注入——可單獨使用

類型
使用在字段上用於根據類型依賴注入
作用：自動封裝該屬性、或者字段
可不用Setter方法接收

    @Autowired
    @Qualifier("userDao")

@Qualifier——name——@Autowired+按名稱注入——必須配合使用

id＋name
結合@Autowired一起使用用於根據名稱進行依賴注入
根據提供的修飾語 @Qualifier('xxx')——>匹配該xxx屬性,
使用該注解,必須配合AutoWire一起使用,
Qualifier:修飾語 ByName
	@Autowire 
	@Qualifier("user") 
	意義：封裝user注解的bean為本類對象的成員,根據名稱注入 ByName,設置在字段上. 

	@Qualifier常用在參數賦值上
	如: String getUsername(@Qualifier("user")User user){}

    @Autowired
    @Qualifier("userDao")

@Resource——按名稱注入＝@Autowired+@Qualifier

相當於@Autowired+@Qualifier， 按照名稱進行注入
Resource是Aotuwire注解和Qualifier注解的結合體.@Resource("user"),標注為user的bean

@Resource("user") 封裝user注解的bean為奔雷對象的成員 	== 
	@Autowire 
	@Qualifier
	
默認根據名稱依賴注入,

默認Resource() = Resource like Resource(name = "XXX")——>體現面向對象思想
應該設置在字段上

可以手動設置為根據類型注入Resource(type = User.class)——>體現面向對象思想
應該設置在set方法上

@Value——注入普通屬性

注入普通屬性
@Value("xxx");為修飾字段賦值;
	通常配合SpEL(Spring Expression Language)使用

@Value("${jdbc.url}") private String url; 為url賦值
	——> (Spring中引入的properties后綴文件中的jdbc.url對應的值) 
	——>或者{PropertySrouce注解中的jdbc.url值}

@Scope——Bean作用范圍

標注Bean的作用范圍
常用 : 	@Scope("singleton") 聲明從spring容器獲得的該類的bean
				有且只有一個(單例模式)
				
		@Scope("prototype") 聲明從spring容器獲得的該類的bean
				有多個(標准Bean模式)

@Post Construct——Bean初始化方法

使用在方法上標注該方法是Bean的初始化方法
注解使用在用戶定義的初始化方法前,
聲明該方法是該類的初始化方法
@PostConstruct :意為執行在構造方法后,構造方法創建對象,對象調用該初始化方法

@Pre Destroy——Bean銷毀方法

使用在方法上標注該方法是Bean的銷毀方法
注解使用在用戶自定義的結束方法前,
聲明該方法是該類的結束方法,
當前對象被銷毀前調用該方法
@PreDestroy ;Spring容器被銷毀的時候,執行.

@Order——注入對象引用集合

注入對象引用的集合的時候使用:
@Order(1) 
@Order(2) 表示該類生成的bean將會存儲在某個List<該類型>中,並按照順序插入List

如果是Map<String,T> 那么order的順序沒有任何關系,
但是該Map必須定義為<String,T> String接收對應對象的id值(id唯一 ——> key唯一);

此處的List和Map可以通過@Autowired或@Resource注入;

2、組件掃描：component-scan

注意：注解開發時需在applicationContext.xml中配置組件掃描
作用:：指定哪一個包及其包下的Bean需要掃描以便識別使用注解配置的類和方法
包：基礎包＋包括里面的子包

    <!--注解開發——需要配置組件掃描-->
    <!--組件掃描——掃描指定文件夾下的包-->
    <context:component-scan base-package="com.remli"/>

3、2種配置/注解方式對比：

1.原始xml配置方式

    <!--xml配置-->
    <bean id="userDao" class="com.remli.dao.impl.UserDaoImpl"></bean>
	
    <bean id="userService" class="com.remli.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
     </bean>

public interface UserDao {
    public void start();
}

public class UserDaoImpl implements UserDao {
    public void start(){
        System.out.println("啟動程序1·····");
    }
}

public interface UserService {
    public void start();
}

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    /*Setter方法*/
    public void setUserDao(UserDao userDao){
        this.userDao=userDao;
    }
    
    public void start(){
        System.out.println("程序啟動2·····");
    }
}

public class UserController {

    public static void main(String[] args) {

        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserService userService = app.getBean(UserService.class);

        userService.start();
    }

}

2.注解@方式！！！

    <!--注解開發——需要配置組件掃描-->
    <!--組件掃描——掃描指定文件夾下的包-->
    <context:component-scan base-package="com.remli"/>

public interface UserDao {
    public void start();
}

/*xml配置定位類文件位置*/
/*
<bean id="userDao" class="com.remli.dao.impl.UserDaoImpl"></bean>
*/

/*注解*/
/*
@component
*/

@Component("userDao")/*相當於配置文件id、定位類*/
public class UserDaoImpl implements UserDao {
    public void start(){
        System.out.println("啟動程序1·····");
    }
}

public interface UserService {
    public void start();
}

/*xml配置定位類文件位置*/
/*
<bean id="userService" class="com.remli.service.impl.UserServiceImpl"></bean>
*/


/*注解*/
/*
@component
*/

@Component("userService")/*相當於配置文件id、定位類*/
public class UserServiceImpl implements UserService {

    /*xml配置注入屬性*/
    /*
    <property name="userDao" ref="userDao"></property>
    */

    /*注解——注入*/
    /*
    @Autowired
    @Qualifier("userDao")
    */

    @Autowired
    @Qualifier("userDao")
    private UserDao userDao;

    /*Setter方法*/
    public void setUserDao(UserDao userDao){
        this.userDao=userDao;
    }

    public void start(){
        System.out.println("程序啟動2·····");
    }
}

public class UserController {

    public static void main(String[] args) {

        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserService userService = app.getBean(UserService.class);

        userService.start();
    }

}

2、Spring新注解

@Configuration——指定類為Spring配置類

用於指定當前類是一個Spring配置類，當創建容器時會從該類上加載注解

@ComponentScan——指定Spring初始化容器掃描包

用於指定Spring在初始化容器時要掃描的包
作用和在Spring的xml配置文件中的

<context:component-scan base-package=”com.code_g”/>一樣

ComponentScan:組件掃描 ByPackage ComponentScan:在使用全注解的時候,非常重要.如果未配置,那么Spring的IoC容器默認不會掃描任何包,就不會有任何Bean.

@Bean——方法返回值存儲到Spring容器中

使用在方法上，標注將該方法的返回值存儲到Spring容器中

@PropertySource——加載properties文件配置

用於加載.properties文件中的配置

@Import——導入其他類配置

用於導入其他配置類

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。