spring

• 一、spring文件及注解
• • 1、spring配置主要全部文件
  • • pom.xml
    • applicationContext.xml
    • Main.java
    • UserDao.java
    • UserDaoImpl.java
  • 2、spring配置主要全部注解
  • 3、Spring重點基礎(chǔ)知識
  • • 1.名詞解釋
    • 2.Bean生命周期：1實例化、2屬性賦值、3初始化、4使用、5銷毀
    • 3.Bean 標簽屬性
    • 4.Spring核心：
  • 4、bean實例化：無參、工廠靜態(tài)、工廠實例
  • • 1.無參構(gòu)造方法實例化：默認
    • 2.工廠靜態(tài)方法實例化：直接調(diào)用方法
    • 3.工廠實例方法實例化：先有工廠對象再調(diào)方法
  • 5、依賴注入DI：注入類型：對象、普通數(shù)據(jù)、集合數(shù)據(jù)
  • • 1.構(gòu)造方法注入：有參構(gòu)造
    • 2.set方法注入：
    • 3.p命名空間注入：(本質(zhì)set)
    • • 1引入p命名空間：
      • 2修改注入方式：
  • 6、依賴注入類型：引用數(shù)據(jù)(對象)、普通數(shù)據(jù)、集合數(shù)據(jù)
  • • 1.普通數(shù)據(jù)
    • 2.引用數(shù)據(jù)
    • 3.集合數(shù)據(jù)
• 三、引入其他配置文件（分模塊開發(fā)）
• • 1、< import >標簽
• 四、Spring的重點配置
• • 1、< property >標簽：屬性注入、setter()
  • • 1. name屬性：屬性名稱
    • 1. value屬性：注入的普通屬性值
    • 1. ref屬性：注入的對象引用值
    • 1. < set >標簽：集合——引用ref
    • 1. < list >標簽：集合——引用ref
    • 1. < map >標簽：集合——鍵值對
    • 1. < properties >標簽：與map類似——鍵值對
  • 2、< constructor-arg >標簽：指定構(gòu)造函數(shù)的參數(shù)注入
• 五、SpringAPI
• • 1、ApplicationContext的繼承
  • 2、ApplicationContext的實現(xiàn)類
  • • 1.ClassPathXmlApplicationContext：類 路徑 文件類型 應(yīng)用 上下文——resource下文件(相對)
    • 2.FileSystemXmlApplicationContext：文件 系統(tǒng) 文件類型 應(yīng)用 上下文——磁盤絕對路徑
    • 3.AnnotationConfigApplicationContext：注解 配置 應(yīng)用 上下文——注解開發(fā)
  • 3、getBean()方法的使用
  • • 1.強轉(zhuǎn)類型
    • 2.直接獲取類對象：類文件直接指定
    • 3.通過java對象獲取
• 六、配置數(shù)據(jù)源
• • 1 、數(shù)據(jù)源（連接池）的作用
  • • 1.提高程序性能
    • 2.事先實例化數(shù)據(jù)源、初始化部分連接資
    • 3.使用連接資源時從數(shù)據(jù)源中獲取
    • 4.使用完畢后將連接資源歸還給數(shù)據(jù)源
  • 2 、引入相關(guān)坐標依賴
  • 3、手動創(chuàng)建C3P0數(shù)據(jù)源：一定要注意空格、注意名稱正確
  • 4、手動創(chuàng)建Druid數(shù)據(jù)源：一定要注意空格、注意名稱正確
  • 5、手建C3P0(加載properties配置文件)：注意空格、名稱正確
  • • 1.創(chuàng)建代碼：
    • 2.配置文件jdbc.properties：注意語句正確、空格、名稱
• 七、Spring配置數(shù)據(jù)源：DataSource——.set方法注入
• • 1、application配置文件：配置連接信息——com.mchange.v2.c3p0.ComboPooledDataSource
  • • 1.注意一個問題：&會報錯——寫成&
  • 2、代替ComboPooledDataSource——>ClassPathXmlApplicationContext
• 八、Spring單獨配置數(shù)據(jù)源：xml加載properties文件——分開數(shù)據(jù)庫與Spring
• • 1、spring加載properties文件步驟：
  • • 1.引入context命名空間和約束路徑：
    • • 1命名空間：xmlns:context="http://www.springframework.org/schema/context"
      • 2約束路徑：http://www.springframework.org/schema/context
    • 2.加載配置文件標簽：< context:property-placeholder location="xx.properties"/ >
    • 3.< property name="" value="${key}"/ >：spr語言——EL
    • 4.DataSource.class
    • 5.DruidDataSource.class
• 九、Spring注解開發(fā)
• • 1、 Spring原始注解
  • • @Component——id——實例化——隨便那個——無語義
    • @Controller——Web層控制類實例化——語義化
    • @Service——Service層服務(wù)類實例化——語義化
    • @Repository——id——Dao層數(shù)據(jù)存儲類實例化——語義化
    • @Autowired——無需Setter——字段按類型注入——可單獨使用
    • @Qualifier——name/id——@Autowired+按名稱注入——必須配合使用
    • @Resource——按名稱注入＝@Autowired+@Qualifier——J2EE提供
    • @Value——注入普通屬性
    • @Scope——Bean作用范圍
    • @PostConstruct——Bean初始化方法——構(gòu)造后
    • @PreDestroy——Bean銷毀方法——銷毀前
    • @Order——注入對象引用集合
  • 2、組件掃描：component-scan
  • 3、2種配置/注解方式對比：
  • • 1.原始xml配置方式
    • 2.注解@方式！！！
  • 2、Spring新注解
  • • @Configuration——指定類為Spring配置類
    • @ComponentScan——指定Spring初始化容器掃描包
    • @Bean——用在方法上、方法返回值存儲到Spring容器中
    • @PropertySource——加載properties文件配置
    • @Import——導(dǎo)入其他類配置
  • 3、Spring對象創(chuàng)建——實例化——找到類創(chuàng)建對象——所在位置
  • • @Component——隨便
    • @Controller——web視圖控制層
    • @Service——Service業(yè)務(wù)服務(wù)層
    • @Repository——Dao數(shù)據(jù)持久化層
  • 4、Spring注入
  • • 1.對象注入：依據(jù)、bean(id)＝name、類、屬性注入
    • • @Resource：默認按名稱byName注入——(J2EE提供注解)——需添加其依賴
      • • 1name: Spring 將 name 的屬性值解析為 bean 的名稱， 使用 byName 的自動注入策略
        • 2type: Spring 將 type的屬性值解析為 bean 的類型，使用 byType 的自動注入策略
        • 3反射—— byName 自動注入策略
      • @Autowried：默認按類型byType注入
      • @Qualifier：默認類名
    • 2.普通屬性注入：——Value

一、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視圖表現(xiàn)層支持————————————————--><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.3.7</version></dependency><!--————————————————添加Spring 數(shù)據(jù)庫事務(wù)管理支持————————————————--><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/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-3.2.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.2.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.2.xsdhttp://www.springframework.org/schema/txhttp://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");/*對象獲取并強制轉(zhuǎn)換類型*/UserDao userDao = (UserDao) app.getBean("userDao");/*對象調(diào)用方法*/userDao.save();} /*獲取文件流*/ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");/*接口*/ /*接口實現(xiàn)*//*獲取對象*/ /*強轉(zhuǎn)對象*/UserService userService = (UserService) app.getBean("userService");userService.save();

UserDao.java

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

UserDaoImpl.java

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

2、spring配置主要全部注解

3、Spring重點基礎(chǔ)知識

1.名詞解釋

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

實例：一個真實的對象

對象（個人）：組成類的元素、類的具體實現(xiàn)、實際執(zhí)行者

屬性：數(shù)據(jù)（變量/值）

定義：編譯器創(chuàng)建對象、分配內(nèi)存、取名(變量名/對象名)

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

實例化：類創(chuàng)建對象的過程

初始化：為變量分配內(nèi)存空間、并確定其初始值的過程

構(gòu)造方法：與類同名的特殊方法、創(chuàng)建對象

構(gòu)造器：與類同名的特殊方法、創(chuàng)建對象

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

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

執(zhí)行Instantiation Aware Bean PostProcessor Adapter的determine Candidate Constructors方法

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

實例化Bean(執(zhí)行Bean構(gòu)造方法)

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

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

屬性賦值(Populate)

Aware接口

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

自定義初始化方法

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

容器創(chuàng)建成功，提供使用

調(diào)用自定義銷毀方法方法

3.Bean 標簽屬性

id 屬性：唯一性、不可重復(fù)
屬性值任意命名，但不可以包含中文以及特殊字符。
根據(jù) id 屬性值得到配置對象。

class 屬性：類的全路徑名稱
創(chuàng)建對象所在類的全路徑名稱。

name 屬性：不可重復(fù)
功能和 id 一致。已基本不用。
區(qū)別： id 屬性值不可以包含特殊字符， name 屬性值可以包含。

scope 屬性
bean 作用范圍屬性值：

取值范圍

singleton 單例	默認值、只生成1個實例
prototype 多例	多例的
request	WEB項目中， Spring創(chuàng)建一個Bean的對象， 將對象存入到request域中
session	WEB項目中， Spring創(chuàng)建一個Bean的對象， 將對象存入到session域中
global session	WEB項目中， 應(yīng)用在Portlet環(huán)境， 如果沒有Portlet環(huán)境那么global Session相當(dāng)于session

作用域：scope

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

4.Spring核心：

Spring容器接口：ApplicationContext

ClassPathXmlApplicationContext: 從類加載路徑下搜索配置文件，并根據(jù)配置文件來創(chuàng)建Spring容器。FileSystemXmlApplicationContext: 從文件系統(tǒng)的相對路徑或絕對路徑下去搜索配置文件，并根據(jù)配置文件來創(chuàng)建Spring容器。

4、bean實例化：無參、工廠靜態(tài)、工廠實例

1.無參構(gòu)造方法實例化：默認

<!--找無參構(gòu)造方法--><bean id="userDao" class="com.remli.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy" scope="prototype"></bean> /*重寫無參構(gòu)造——修改默認構(gòu)造方法——對應(yīng)接口*/ public UserDaoImpl(){System.out.println("無參構(gòu)造修改：UserDaoImpl對象創(chuàng)建..."); }

2.工廠靜態(tài)方法實例化：直接調(diào)用方法

<!--找全包名對應(yīng)內(nèi)部指定的方法、去返回對應(yīng)的對象--><bean id="userDao1" class="com.remli.factory.StaticFactory" scope="prototype" factory-method="getUserDao"></bean> public class StaticFactory {/*對象工廠——對象創(chuàng)建——返回對象*/public static UserDao getUserDao() {/*返回對象*/return new UserDaoImpl();} }

3.工廠實例方法實例化：先有工廠對象再調(diào)方法

<!--先創(chuàng)建工廠對象--><bean id="factory" class="com.remli.factory.DynamicFactory" scope="prototype" ></bean><!--從容器當(dāng)中工廠對象內(nèi)部的方法獲取指定返回的對象--><bean id="userDao2" factory-bean="factory" factory-method="getUserDao"></bean> public class DynamicFactory {/*對象工廠*/public UserDao getUserDao() {/*返回對象*/return new UserDaoImpl();} }

5、依賴注入DI：注入類型：對象、普通數(shù)據(jù)、集合數(shù)據(jù)

1.構(gòu)造方法注入：有參構(gòu)造

<bean id="userService" class="com.remli.service.impl.UserServiceImpl"><!--參數(shù)名--> <!----><constructor-arg name="userDao" ref="userDao"></constructor-arg></bean> public UserServiceImpl(UserDao userDao) {/*有參構(gòu)造*/this.userDao = userDao;}

2.set方法注入：

<!--找無參構(gòu)造方法--><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命名空間注入：(本質(zhì)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、依賴注入類型：引用數(shù)據(jù)(對象)、普通數(shù)據(jù)、集合數(shù)據(jù)

1.普通數(shù)據(jù)

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");/*接口*/ /*接口實現(xiàn)*/UserDao ud = (UserDao) app.getBean("userDao11");/*獲取對象*/ /*強轉(zhuǎn)對象*/Object ud1 = app.getBean("userDao11");ud.save();

2.引用數(shù)據(jù)

3.集合數(shù)據(jù)

/*定義變量、構(gòu)造方法*/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;}/*實現(xiàn)接口的類的方法*/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;}@Overridepublic 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");/*接口*/ /*接口實現(xiàn)*/UserDao u2= (UserDao) app.getBean("userDao222");/*獲取對象*/ /*強轉(zhuǎn)對象*/Object d2 = app.getBean("userDao222");u2.save();

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

實際開發(fā)中，Spring的配置內(nèi)容非常多，這導(dǎo)致Spring配置很繁雜，使用可以拆分到其它配置文件當(dāng)
中，而且Spring主配置文件通過import標簽加載

1、< import >標簽

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

四、Spring的重點配置

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

property：通過setter對應(yīng)的方法注入。

<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 >標簽：指定構(gòu)造函數(shù)的參數(shù)注入

constructor-arg：通過構(gòu)造函數(shù)注入。

<!--找無參構(gòu)造方法--><bean id="userDao" class="com.remli.dao.impl.UserDaoImpl"></bean> <bean id="userService" class="com.remli.service.impl.UserServiceImpl"><!--參數(shù)名--> <!----><constructor-arg name="userDao" ref="userDao"></constructor-arg></bean>

constructor-arg屬性通過指定type 類型來調(diào)用對應(yīng)的構(gòu)造函數(shù)，

<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:接口類型，代表應(yīng)用上下文，可通過其實例獲得Spring容器中的Bean對象。

2、ApplicationContext的實現(xiàn)類

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

它是從類的根路徑下加載配置文件（常用） /*獲取文件流*/ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");/*接口*/ /*接口實現(xiàn)*/

2.FileSystemXmlApplicationContext：文件 系統(tǒng) 文件類型 應(yīng)用 上下文——磁盤絕對路徑

它是從磁盤路徑上加載配置文件，配置文件可以在磁盤的任何位置。 ApplicationContext appp = new FileSystemXmlApplicationContext("C:\\Users\\REMLI\\IdeaProjects\\REM_SSMS\\src\\main\\resources\\applicationContext.xml");

3.AnnotationConfigApplicationContext：注解 配置 應(yīng)用 上下文——注解開發(fā)

當(dāng)使用注解配置容器對象時，需要使用此類來創(chuàng)建Spring容器。它用來讀取注解。

3、getBean()方法的使用

1.強轉(zhuǎn)類型

一個是通過id來獲取：某一個類型可存在多個，獲取后需要強轉(zhuǎn)。 UserDao u111= (UserDao) appp.getBean("userDao222");

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

一個通過返回值來獲取：一種類型只能有一個，獲取后不需要強轉(zhuǎn)。 UserDao userDao = app.getBean(UserDao.class);

3.通過java對象獲取

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

六、配置數(shù)據(jù)源

1 、數(shù)據(jù)源（連接池）的作用

1.提高程序性能

2.事先實例化數(shù)據(jù)源、初始化部分連接資

3.使用連接資源時從數(shù)據(jù)源中獲取

4.使用完畢后將連接資源歸還給數(shù)據(jù)源

常見數(shù)據(jù)源：DBCP，C3P0，BoneCP、Druid等

2 、引入相關(guān)坐標依賴

<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、手動創(chuàng)建C3P0數(shù)據(jù)源：一定要注意空格、注意名稱正確

@Test/*測試手動創(chuàng)建c3p0數(shù)據(jù)源*/public void test1() throws Exception {/*創(chuàng)建數(shù)據(jù)源*//*康波坡爾*//*注意一個問題保證mysql語句的正確、Mysql 8.0.19和以前版本連接語句略微不同*//*實例化對象*/ComboPooledDataSource dataSource = new ComboPooledDataSource();/*對象調(diào)用方法——并set方法賦值*//*賦值驅(qū)動類數(shù)據(jù)庫連接信息*/dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/remli?useSSL=false&serverTimezone=UTC");dataSource.setUser("root");dataSource.setPassword("2020");/*創(chuàng)建對象獲取連接信息*/Connection connection = dataSource.getConnection();/*打印對象信息*/System.out.println("\n地址："+connection);/*連接關(guān)閉、歸還資源*/connection.close();}

4、手動創(chuàng)建Druid數(shù)據(jù)源：一定要注意空格、注意名稱正確

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

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

1.創(chuàng)建代碼：

@Test/*測試手動創(chuàng)建c3p0數(shù)據(jù)源(加載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");/*創(chuàng)建數(shù)據(jù)源對象、設(shè)置連接參數(shù)*//*康波坡爾*//*注意一個問題保證mysql語句的正確、Mysql 8.0.19和以前版本連接語句略微不同*//*實例化對象*/ComboPooledDataSource dataSource = new ComboPooledDataSource();/*對象調(diào)用方法——并set方法賦值*//*賦值驅(qū)動類數(shù)據(jù)庫連接信息*//*注意值不能加雙引號*/dataSource.setDriverClass(driver);dataSource.setJdbcUrl(url);dataSource.setUser(username);dataSource.setPassword(password);/*創(chuàng)建對象獲取連接信息*/Connection connection = dataSource.getConnection();/*打印對象信息*/System.out.println("\n地址："+connection);/*連接關(guān)閉、歸還資源*/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配置數(shù)據(jù)源：DataSource——.set方法注入

將DataSource創(chuàng)建權(quán)——交給Spring容器完成 DataSource有無參構(gòu)造方法——Spring默認通過無參構(gòu)造方法實例化對象 使用DataSource獲取數(shù)據(jù)庫的連接對象——需通過set方法設(shè)置數(shù)據(jù)庫連接信息——Spring可通過set方法進行字符串注入

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

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

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"><!--set方法注入?yún)?shù)--><!--這里的名稱是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容器產(chǎn)生數(shù)據(jù)源對象(加載application.xml配置文件)*/public void test4() throws Exception {/*讀取配置文件*/ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");/*創(chuàng)建數(shù)據(jù)源對象、設(shè)置連接參數(shù)*//*實例化對象*/DataSource dataSource4 = app.getBean(DataSource.class);/*創(chuàng)建對象獲取連接信息*/Connection connection4 = dataSource4.getConnection();/*打印對象信息*/System.out.println("\n地址："+connection4);/*連接關(guān)閉、歸還資源*/connection4.close();}

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

properties的鍵值對寫法需要注意不要有鍵名相同！！！ 各自的數(shù)據(jù)庫——加載——對應(yīng)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容器當(dāng)中, 可以通過spel,即${}獲取到值,例如配置數(shù)據(jù)庫連接參數(shù) 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.xsdspring啟動時需驗證xml文檔,約束的作用就是來驗證配置文件的xml文檔語法的正確性。 http://www.springframework.org/schema/context/spring-context.xsd

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

<context:property-placeholder />:加載外部的.properties文件到spring容器當(dāng)中, 可以通過spel,即${}獲取到值,例如配置數(shù)據(jù)庫連接參數(shù) <!--加載外部properties配置文件--><context:property-placeholder location="classpath:jdbc.properties"/>

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

獲取key值——獲取properties對應(yīng)名稱值

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"><!--set方法注入?yún)?shù)--><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

<!--解耦合--><!--這個地方可以更換數(shù)據(jù)源--><!--加載外部properties配置文件--><context:property-placeholder location="classpath:jdbc.properties"/><bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"><!--set方法注入?yún)?shù)--><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容器產(chǎn)生數(shù)據(jù)源對象(加載application.xml配置文件)*/public void test4() throws Exception {/*讀取配置文件*/ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");/*創(chuàng)建數(shù)據(jù)源對象、設(shè)置連接參數(shù)*//*實例化對象*/DataSource dataSource4 = app.getBean(DataSource.class);/*創(chuàng)建對象獲取連接信息*/Connection connection4 = dataSource4.getConnection();/*打印對象信息*/System.out.println("\n地址4："+connection4);/*連接關(guān)閉、歸還資源*/connection4.close();}

5.DruidDataSource.class

<!--解耦合--><!--這個地方可以更換數(shù)據(jù)源--><!--加載外部properties配置文件--><context:property-placeholder location="classpath:jdbc.properties"/><bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource"><!--set方法注入?yún)?shù)--><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容器產(chǎn)生數(shù)據(jù)源對象(加載application.xml配置文件)*/public void test5() throws Exception {/*讀取配置文件*/ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");/*創(chuàng)建數(shù)據(jù)源對象、設(shè)置連接參數(shù)*//*實例化對象*/DruidDataSource dr = app.getBean(DruidDataSource.class);/*創(chuàng)建對象獲取連接信息*/Connection connection5 = dr.getConnection();/*打印對象信息*/System.out.println("\n地址5："+connection5);/*連接關(guān)閉、歸還資源*/connection5.close();} 2者不能同時開啟、會相互報錯總結(jié)：命名空間修改方法，賦值xmlns后的url，將beans改為context，然后建立新的xmlns:context。 復(fù)制前一段xsi：schemaLocation將所有的beans都改為context添加在后面。 引入文件路徑，classpath表示class文件路徑，resource文件默認保存在classpath文件下， 所以路徑為"classpath:jdbc.properties"。 在xml中調(diào)用properties文件，使用EL表達式。問題記錄：導(dǎo)入properties后，Druid報錯：[create connection SQLException, url:jdbc:mysql://localhost:3306/demo, errorCode 1045, state 28000]錯誤原因：properties配置文件中的名字與Driud屬性名沖突。修改前：driver=com.mysql.cj.jdbc.Driverurl=jdbc:mysql://localhost:3306/remli?useSSL=false&serverTimezone=UTCusername=rootpassword=2020修改后：jdbc.driver=com.mysql.cj.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/remli?useSSL=false&serverTimezone=UTCjdbc.username=rootjdbc.password=2020

九、Spring注解開發(fā)

語義化：見名知意

1、 Spring原始注解

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

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

使用在類上用于實例化Bean 該組件用于Spring生成一個bean——>Component:組件 Component:組件 ByID @Component("userDao")/*相當(dāng)于配置文件id、定位類*/ @Component("userService")/*相當(dāng)于配置文件id、定位類*/

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

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

@Service——Service層服務(wù)類實例化——語義化

使用在service層類上用于實例化Bean 該業(yè)務(wù)邏輯類用于Spring生成一個bean @Service("userService")/*相當(dāng)于配置文件id、定位類*/

@Repository——id——Dao層數(shù)據(jù)存儲類實例化——語義化

使用在dao層類上用于實例化Bean 該Dao類用于Spring生成一個bean——>repository:貯藏室 數(shù)據(jù)封裝基地 Repository:貯藏室 ByID @Repository("userDao")/*相當(dāng)于配置文件id、定位類*/ @Controller @Service @Repository @Component 4者無本質(zhì)區(qū)別 他們存在是為區(qū)分開web、service、dao層 方便代碼閱讀。

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

類型 使用在字段上用于根據(jù)類型依賴注入 作用：自動封裝該屬性、或者字段 可不用Setter方法接收單個類：獨自使用 @Autowired//單個使用——按照數(shù)據(jù)類型從Spring容器中匹配進行注入、注意單個數(shù)據(jù)類可以、多個就識別確定不了 結(jié)合@Qualifier使用： @Autowired//單個使用——按照數(shù)據(jù)類型從Spring容器中匹配進行注入、//注意單個數(shù)據(jù)類可以、多個就識別確定不了@Qualifier("userDao")//按照id從容器中進行匹配//但是此處需要結(jié)合@Autowired一起使用

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

id＋name 結(jié)合@Autowired一起使用用于根據(jù)名稱進行依賴注入 根據(jù)提供的修飾語 @Qualifier('xxx')——>匹配該xxx屬性, 使用該注解,必須配合AutoWire一起使用, Qualifier:修飾語 ByName@Autowire @Qualifier("user") 意義：封裝user注解的bean為本類對象的成員,根據(jù)名稱注入 ByName,設(shè)置在字段上. @Qualifier常用在參數(shù)賦值上如: String getUsername(@Qualifier("user")User user){}結(jié)合@Qualifier使用： @Autowired//單個使用——按照數(shù)據(jù)類型從Spring容器中匹配進行注入、//注意單個數(shù)據(jù)類可以、多個就識別確定不了@Qualifier("userDao")//按照id從容器中進行匹配//但是此處需要結(jié)合@Autowired一起使用 @Autowired@Qualifier("userDao")

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

相當(dāng)于@Autowired+@Qualifier， 按照名稱進行注入 Resource是Aotuwire注解和Qualifier注解的結(jié)合體.@Resource("user"),標注為user的bean@Resource("user") 封裝user注解的bean為奔雷對象的成員 == @Autowire @Qualifier默認根據(jù)名稱依賴注入,默認Resource() = Resource like Resource(name = "XXX")——>體現(xiàn)面向?qū)ο笏枷?應(yīng)該設(shè)置在字段上可以手動設(shè)置為根據(jù)類型注入Resource(type = User.class)——>體現(xiàn)面向?qū)ο笏枷?應(yīng)該設(shè)置在set方法上 @Resource(name="userDao")//相當(dāng)于 @Autowired＋@Qualifier("userDao")

@Value——注入普通屬性

注入普通屬性 @Value("xxx");為修飾字段賦值;通常配合SpEL(Spring Expression Language)使用@Value("${jdbc.url}") private String url; 為url賦值——> (Spring中引入的properties后綴文件中的jdbc.url對應(yīng)的值) ——>或者{PropertySrouce注解中的jdbc.url值} @Value("value注入成功")//屬性值注入private String vals;@Value("${jdbc.driver}")//數(shù)據(jù)庫屬性值注入private String sjk;

@Scope——Bean作用范圍

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

@PostConstruct——Bean初始化方法——構(gòu)造后

使用在方法上標注該方法是Bean的初始化方法 注解使用在用戶定義的初始化方法前, 聲明該方法是該類的初始化方法 @PostConstruct :意為執(zhí)行在構(gòu)造方法后,構(gòu)造方法創(chuàng)建對象,對象調(diào)用該初始化方法 @PostConstructpublic void init(){System.out.println("Service對象初始化方法");}

@PreDestroy——Bean銷毀方法——銷毀前

使用在方法上標注該方法是Bean的銷毀方法 注解使用在用戶自定義的結(jié)束方法前, 聲明該方法是該類的結(jié)束方法, 當(dāng)前對象被銷毀前調(diào)用該方法 @PreDestroy ;Spring容器被銷毀的時候,執(zhí)行. @PreDestroypublic void destory(){System.out.println("Service對象銷毀方法"); // /*讀取配置文件*/ // /*子類實現(xiàn)銷毀方法——手動關(guān)閉*/ // ClassPathXmlApplicationContext apps = new ClassPathXmlApplicationContext("applicationContext.xml"); // // /*創(chuàng)建數(shù)據(jù)源對象、設(shè)置連接參數(shù)*/ // /*實例化對象*/ // XXX drs = app.getBean(XXX.class); // // /*手動關(guān)閉*/ // drs.close();}

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

注入對象引用的集合的時候使用: @Order(1) @Order(2) 表示該類生成的bean將會存儲在某個List<該類型>中,并按照順序插入List如果是Map<String,T> 那么order的順序沒有任何關(guān)系, 但是該Map必須定義為<String,T> String接收對應(yīng)對象的id值(id唯一 ——> key唯一);此處的List和Map可以通過@Autowired或@Resource注入;

2、組件掃描：component-scan

注意：注解開發(fā)時需在applicationContext.xml中配置組件掃描 作用:：指定哪一個包及其包下的Bean需要掃描以便識別使用注解配置的類和方法 包：基礎(chǔ)包＋包括里面的子包 <!--注解開發(fā)——需要配置組件掃描--><!--組件掃描——掃描指定文件夾下的包--><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.注解@方式！！！

<!--注解開發(fā)——需要配置組件掃描--><!--組件掃描——掃描指定文件夾下的包--><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")/*相當(dāng)于配置文件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")/*相當(dāng)于配置文件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配置類

用于指定當(dāng)前類是一個Spring配置類，當(dāng)創(chuàng)建容器時會從該類上加載注解

@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——導(dǎo)入其他類配置

用于導(dǎo)入其他配置類

3、Spring對象創(chuàng)建——實例化——找到類創(chuàng)建對象——所在位置

@Component——隨便

定義Bean, 不好歸類時使用

@Controller——web視圖控制層

@Controller("Bean的名稱") 定義控制層Bean,如Action

@Service——Service業(yè)務(wù)服務(wù)層

@Service("Bean的名稱") 定義業(yè)務(wù)層Bean

@Repository——Dao數(shù)據(jù)持久化層

@Repository("Bean的名稱") 定義DAO層Bean

4、Spring注入

1.對象注入：依據(jù)、bean(id)＝name、類、屬性注入

@Resource：默認按名稱byName注入——(J2EE提供注解)——需添加其依賴

Spring將@Resource注解的name屬性解析為bean的名字，而type屬性則解析為bean的類型。 默認是按照名稱來裝配注入的，只有當(dāng)找不到與名稱匹配的bean才會按照類型來注入。 它有兩個屬性是比較重要的: 如果想減少對 Spring 的依賴建議使用 @Resource 方法。 <!--Resource注解依賴--><!-- https://mvnrepository.com/artifact/javax.annotation/javax.annotation-api --><dependency><groupId>javax.annotation</groupId><artifactId>javax.annotation-api</artifactId><version>1.3.2</version></dependency><!-- Javax Annotation --><dependency><groupId>javax.annotation</groupId><artifactId>jsr250-api</artifactId><version>1.0</version></dependency>

1name: Spring 將 name 的屬性值解析為 bean 的名稱， 使用 byName 的自動注入策略

2type: Spring 將 type的屬性值解析為 bean 的類型，使用 byType 的自動注入策略

3反射—— byName 自動注入策略

如果既不指定 name 屬性又不指定 type 屬性，Spring這時通過反射機制使用 byName 自動注入策略@Resource 裝配順序：如果同時指定了 name 屬性和 type 屬性，那么 Spring 將從容器中找唯一匹配的 bean 進行裝配，找不到則拋出異常如果指定了 name 屬性值，則從容器中查找名稱匹配的 bean 進行裝配，找不到則拋出異常如果指定了 type 屬性值，則從容器中查找類型匹配的唯一的 bean 進行裝配，找不到或者找到多個都會拋出異常如果都不指定，則會自動按照 byName 方式進行裝配， 如果沒有匹配，則回退一個原始類型進行匹配，如果匹配則自動裝配

@Autowried：默認按類型byType注入

默認是按照類型進行裝配注入， 默認情況下，它要求依賴對象必須存在，如果允許 null 值，可以設(shè)置它 required 為false。 如果我們想要按名稱進行裝配的話，可以添加一個 @Qualifier 注解解決。@Autowired 接口只能有一個實現(xiàn)類，通過byType方式注入 默認情況下必須要求依賴對象必須存在，如果要允許null值，可以設(shè)置它的required屬性為false，如：@Autowired(required=false) @Autowried@Qualifier("adminDAO")private AdminDAO adminDAO;

@Qualifier：默認類名

spring的注解，按名字注入 一般當(dāng)出現(xiàn)兩個及以上bean時,不知道要注入哪個，作為@Autowired()的修飾用 @Qualifier 接口可以有多個實現(xiàn)類,可以按實現(xiàn)類的類名進行注入

2.普通屬性注入：——Value

通常不直接賦值，而是調(diào)用引入的properties文件賦值。 只要核心類或者引入的子類引入了properties文件就可以直接用EL表達式。 引入格式為EL表達式使用@Value將外部值動態(tài)的注入到Bean中，使用情況：注入普通字符串注入操作系統(tǒng)屬性注入表達式結(jié)果注入其他Bean屬性：注入beanInject對象的屬性another注入文件資源注入URL資源 @Value("${jdbc.username}")private String name; @Value("normal")private String normal; // 注入普通字符串@Value("#{systemProperties['os.name']}")private String systemPropertiesName; // 注入操作系統(tǒng)屬性@Value("#{ T(java.lang.Math).random() * 100.0 }")private double randomNumber; //注入表達式結(jié)果@Value("#{beanInject.another}")private String fromAnotherBean; // 注入其他Bean屬性：注入beanInject對象的屬性another，類具體定義見下面@Value("classpath:com/hry/spring/configinject/config.txt")private Resource resourceFile; // 注入文件資源@Value("http://www.baidu.com")private Resource testUrl; // 注入URL資源

總結(jié)

以上是生活随笔為你收集整理的2021最新Spring教程（精简）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。