Spring如何通過注解存儲和讀取對象詳解
1. 創(chuàng)建Spring 項目
1） 創(chuàng)建?個普通 Maven 項?。
2.）添加 Spring 框架?持（spring-context、spring-beans）。
3） 添加啟動類。
1.1 創(chuàng)建?個 Maven 項?
1.2 添加 Spring 框架支持
在項?的 pom.xml 中添加 Spring 框架的?持，xml 配置如下：
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
</dependencies>配置國內(nèi)源
將下面兩個框都要勾選上
settings.xml 文件配置代碼：
<mirrors>
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>central</mirrorOf>
</mirror>修改位置如下
配置好之后，如果想下一次的項目也使用該國內(nèi)源，則需下面的配置
1.3 添加啟動類
最后在創(chuàng)建好的項? java ?件夾下創(chuàng)建?個啟動類，包含 main ?法即可
2. 存儲 Bean 對象
存儲 Bean 分為以下 3步：
1）存儲 Bean 之前，先得有 Bean 才?，因此先要創(chuàng)建?個 Bean。
2) 配置?件 spring-config.xml
3）將創(chuàng)建的 Bean 注冊到 Spring 容器中。
2.1 創(chuàng)建Bean
Bean 就是 Java 語?中的?個普通對象，實現(xiàn)代碼如下：
public class User {
public static void say(String name){
System.out.println("hello " + name);
}
}2.2 配置 spring-config.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>再將 User 對象注冊到spring-config.xml 中就可以，具體操作是在 <beans> 中添加如下配置：
3. 獲取并使用 Bean 對象
獲取并使? Bean 對象，分為以下 3 步：
1. 得到 Spring 上下?對象，因為對象都交給 Spring 管理了，所以獲取對象要從 Spring 中獲取，那么就得先得到 Spring 的上下?。
2. 通過 Spring 上下?，獲取某?個指定的 Bean 對象。
3. 使? Bean 對象。
3.1 創(chuàng)建Sprign 上下文
Spring 上下?對象可使? ApplicationContext，代碼如下
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
}
除了 ApplicationContext 之外，我們還可以使? BeanFactory 來作為 Spring 的上下?，如下代碼所示
// 1.得到 bean 工廠
BeanFactory factory = new XmlBeanFactory(
new ClassPathResource("spring-config.xml"));
// 2.獲取 bean
User user = (User) factory.getBean("user");
// 3.使用 bean
user.say("黃小小");ApplicationContext 和 BeanFactory 效果是?樣的，ApplicationContext 屬于 BeanFactory 的?類， 它們的區(qū)別如下
1）繼承關系和功能??來說：Spring 容器有兩個頂級的接?：BeanFactory 和ApplicationContext。
其中 BeanFactory 提供了基礎的訪問容器的能?，? ApplicationContext 屬于 BeanFactory 的?類，它除了繼承了 BeanFactory 的所有功能之外，它還擁有獨特的特性，還添加了對國際化?持、資源訪問?持、以及事件傳播等??的?持。
2）從性能??來說：ApplicationContext 是?次性加載并初始化所有的 Bean 對象，? BeanFactory是需要那個才去加載那個，因此更加輕量。
3.2 獲取指定的 Bean 對象
//2.根據(jù)上下文對象提供的方法獲取到 bean
//User user = (User) context.getBean("user");//與spring-config.xml 中的id 一致
//User user = context.getBean(User.class);//不需要強轉(zhuǎn)，但不建議使用
User user = context.getBean("user",User.class);//精準并不需要強轉(zhuǎn)，推薦使用
3.3 使用Bean
//3.使用
user.say("黃小小");總代碼：
public class App {
public static void main(String[] args) {
//1.得到 spring 上下文對象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
//2.根據(jù)上下文對象提供的方法獲取到 bean
//User user = (User) context.getBean("user");//與spring-config.xml 中的id 一致
//User user = context.getBean(User.class);//不需要強轉(zhuǎn)，但不建議使用
User user = context.getBean("user",User.class);//精準并不需要強轉(zhuǎn)，推薦使用
//3.使用
user.say("黃小小");
}
}
4.總結
更簡單的獲取和存儲對象
5.配置掃描路徑
想要將對象成功的存儲到 Spring 中，我們需要配置?下存儲對象的掃描包路徑，只有被配置的包下的所有類，添加了注解才能被正確的識別并保存到 Spring 中。 在 spring-config.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:content="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 https://www.springframework.org/schema/context/spring-context.xsd">
<content:component-scan base-package="com.beans"></content:component-scan>
</beans>
6.添加注解存儲
bean對象 想要將對象存儲在 Spring 中，有兩種注解類型可以實現(xiàn)：
1） 類注解：@Controller、@Service、@Repository、@Component、@Configuration。
2） ?法注解：@Bean
6.1 @Controller（控制器存儲）
使? @Controller 存儲 bean 的代碼如下所示：
在要掃描的根路徑（com.beans）下創(chuàng)建一個 UserController 類
import org.springframework.stereotype.Controller;
@Controller//將對象存儲到Spring中
public class UserController {
public void sayHi() {
System.out.println("hello controller");
}
}在main 方法中用讀取對象的?式來讀取上?的 UserController 對象，如下代碼所示
public class App {
public static void main(String[] args) {
//1. 先得到上下文對象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
//2.得到bean
UserController controller = context.getBean("userController",UserController.class);
//3.使用 bean
controller.sayHi();
}
}代碼注入解釋：
獲取結果
6.2 @Service （服務器存儲）
使? @Service 存儲 bean 的代碼如下所示：
在要掃描的根路徑（com.beans）下創(chuàng)建一個 UserService類
import org.springframework.stereotype.Service;
@Service
public class UserService {
public void sayHi() {
System.out.println("hello service");
}
}在main 方法中用讀取對象的?式來讀取上?的 UserService 對象，如下代碼所示
public class App {
public static void main(String[] args) {
//1. 先得到上下文對象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
//2.得到bean
UserService service = context.getBean("userService",UserService.class);
//3.使用 bean
service.sayHi();
}
}6.3 @Repository （倉庫存儲）
使? @Repository 存儲 bean 的代碼如下所示：
在要掃描的根路徑（com.beans）下創(chuàng)建一個 UserRepository 類
import org.springframework.stereotype.Repository;
@Repository
public class UserRepository {
public void sayHi() {
System.out.println("hello repository");
}
}在main 方法中用讀取對象的?式來讀取上?的 UserController 對象，如下代碼所示
public class App {
public static void main(String[] args) {
//1. 先得到上下文對象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
//2.得到bean
UserRepository repository = context.getBean("userRepository",UserRepository.class);
//3.使用 bean
repository.sayHi();
}
}6.4 @Component （組件存儲）
使用 @Component 存儲 bean 的代碼如下所示：
在要掃描的根路徑（com.beans）下創(chuàng)建一個 UserComponent 類
import org.springframework.stereotype.Component;
@Component
public class UserComponent {
public void sayHi() {
System.out.println("hello component");
}
}在main 方法中用讀取對象的?式來讀取上?的 UserComponent 對象，如下代碼所示
public class App {
public static void main(String[] args) {
//1. 先得到上下文對象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
//2.得到bean
UserComponent component = context.getBean("userComponent",UserComponent.class);
//3.使用 bean
component.sayHi();
}
}6.5 @Configuration（配置存儲）
使用 @Configuration 存儲 bean 的代碼如下所示：
在要掃描的根路徑（com.beans）下創(chuàng)建一個 UserConfig 類
@Configuration
public class UserConfig {
public void sayHi() {
System.out.println("hello Configuration");
}
}在main 方法中用讀取對象的?式來讀取上?的 UserConfig 對象，如下代碼所示
public class App {
public static void main(String[] args) {
//1. 先得到上下文對象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
//2.得到bean
UserConfig config = context.getBean("userConfig",UserConfig.class);
//3.使用 bean
config.sayHi();
}
}6.6 為什么需要五大注解
讓代碼可讀性提高，能直觀的判斷當前類的用途
查看 @Controller / @Service / @Repository / @Configuration 等注解的源碼發(fā)現(xiàn)，
這些注解??都有?個注解 @Component，說明它們本身就是屬于 @Component 的“?類。
6.7 方法注解 @Bean
6.7.1 方法注解配合類注解使用
1)創(chuàng)建一個 bean
在要掃描的根路徑（com.beans）下創(chuàng)建一個 UserBeans 類
在 Spring 框架的設計中，?法注解 @Bean 要配合類注解才能將對象正常的存儲到 Spring 容器中
@Component
public class UserBeans {
@Bean
public User user1() {
User user = new User();
user.setId(1);
user.setName("黃小小");
return user;
}
}然后創(chuàng)建一個User對象
public class User {
private int id;
private String name;
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}在main 方法中用讀取對象的?式來讀取上?的 User 對象，如下代碼所示
public class App {
public static void main(String[] args) {
//1. 先得到上下文對象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
User user = context.getBean("user1",User.class);
System.out.println(user);
}
}
6.7.2 重命名Bean
當 User 類里面有多個對象時，可以通過設置 name 屬性給 Bean 對象進?重命名操作，如下代碼
@Component
public class UserBeans {
@Bean(name = "in")
public User user1() {
User user1 = new User();
user1.setId(1);
user1.setName("黃小小");
return user1;
}
@Bean(name = "to")
public User user2() {
User user2 = new User();
user2.setId(2);
user2.setName("楊通達");
return user2;
}
}通過使用 Bean 里面的 name 就可以獲取對象了
public class App {
public static void main(String[] args) {
//1. 先得到上下文對象
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
User user1 = context.getBean("in",User.class);
System.out.println(user1);
User user2 = context.getBean("to",User.class);
System.out.println(user2);
}
}
8.獲取 Bean 對象
獲取 bean 對象也叫做對象裝配，是把對象取出來放到某個類中，有時候也叫對象注?。
類似于把 B 中的對象取出來放到 A 類當中
對象裝配（對象注?）的實現(xiàn)?法以下 3 種：
1. 屬性注?
2. 構造?法注?
3. Setter 注?
8.1 屬性注入
屬性注?是使? @Autowired 實現(xiàn)的。
下面將 UserService 類注?到 UserController2 類中。
UserService類
@Service
public class UserService {
public void sayHi() {
System.out.println("hello service");
}
}UserController2 類
@Controller
public class UserController2 {
//對象注入方式1：屬性注入
@Autowired
private UserService userService;
public void sayHi() {
userService.sayHi();
}
}main方法
public class App2 {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
UserController2 userController2 =
context.getBean(UserController2.class);
userController2.sayHi();
}
}獲取結果
整個獲取的調(diào)用鏈過程：
8.2 構造方法注入
其中UserService類和上面屬性注入的一樣。
構造?法注?是在類的構造?法中實現(xiàn)注?，如下代碼所示
@Controller
public class UserController3 {
private UserService userService;
//構造方法注入（官方推薦）
@Autowired
public UserController3(UserService userService) {
this.userService = userService;
}
/*
//當有多個構造方法時，上面的 @Autowired 不能省略
public UserController3(UserService userService, int num) {
this.userService = userService;
}*/
public void sayHi() {
userService.sayHi();
}
}8.3 Setter 注入
Setter 注?和屬性的 Setter ?法實現(xiàn)類似，只不過在設置 set ?法的時候需要加上 @Autowired 注 解，如下代碼所示：
@Controller
public class UserController4 {
private UserService userService;
//Setter 注?
@Autowired
public void setUserService(UserService userService) {
this.userService = userService;
}
public void sayHi() {
userService.sayHi();
}
}8.4 三種注?優(yōu)缺點分析
1）屬性注?的優(yōu)點是簡潔，使??便；缺點是只能?于 IoC 容器，如果是? IoC 容器不可?，并且只有在使?的時候才會出現(xiàn) NPE（空指針異常）。
2）構造?法注?是 Spring 推薦的注??式，它的缺點是如果有多個注?會顯得?較臃腫，但出現(xiàn)這種情況你應該考慮?下當前類是否符合程序的單?職責的設計模式了，它的優(yōu)點是通?性，在使?之前?定能把保證注?的類不為空。
3）Setter ?式是 Spring 前期版本推薦的注??式，但通?性不如構造?法，所有 Spring 現(xiàn)版本已經(jīng)推薦使?構造?法注?的?式來進?類注?了
8.5 @Resource：另一種注入關鍵字
在進?類注?時，除了可以使? @Autowired 關鍵字之外，我們還可以使? @Resource 進?注?，如下代碼所示
@Controller
public class UserController4 {
private UserService userService;
//Setter 注?
//@Autowired
@Resource
public void setUserService(UserService userService) {
this.userService = userService;
}
public void sayHi() {
userService.sayHi();
}
}@Autowired 和 @Resource 的區(qū)別
1）出身不同：@Resource 來自于 JDK ，@Autowrired 是Spring 框架提供的
2）用法不同：@Autowired 支持屬性注入、構造方法注入和Setter 注入，而 @Resource 不支持構造方法注入。
3）支持的參數(shù)不同：@Resource 支持更多的參數(shù)設置，比如 name 、type 設置，而@Autowired 只支持required 參數(shù)設置。
總結
到此這篇關于Spring如何通過注解存儲和讀取對象的文章就介紹到這了,更多相關Spring注解存儲和讀取對象內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要介紹了Java方法的返回值及注意事項,本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2023-04-04
Java 5個人坐在一起(有關第五個人歲數(shù)的問題)
利用遞歸的方法，遞歸分為回推和遞推兩個階段。要想知道第五個人歲數(shù)，需知道第四人的歲數(shù)，依次類推，推到第一人（10歲），再往回推,需要的朋友可以參考下2017-02-02
這篇文章主要介紹了Java 判斷數(shù)組是否相等的方法示例,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2019-09-09
本篇文章主要介紹了Java 操作Properties配置文件詳解，詳細的介紹了Properties和主要方法，有興趣的可以了解下2017-05-05
這篇文章主要介紹了教你怎么用IDEA快速生成注釋文檔,文中有非常詳細的代碼示例,對正在學習IDEA操作的小伙伴們有很好地幫助,需要的朋友可以參考下2021-05-05
這篇文章主要介紹了jenkins+Maven從SVN上構建項目,本文給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2020-09-09
這篇文章主要介紹了Java 匯編JVM編寫jasmin程序的操作方法,本文通過幾個示例講解的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2021-04-04
這篇文章主要介紹了IDEA的run maven方式啟動步驟，本文通過圖文并茂的形式給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下2020-07-07
這篇文章主要為大家介紹了Eureka源碼閱讀解析Server服務端啟動流程實例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-10-10
對于一個算法,其時間復雜度和空間復雜度往往是相互影響的,當追求一個較好的時間復雜度時,可能會使空間復雜度的性能變差,即可能導致占用較多的存儲空間,這篇文章主要給大家介紹了關于Java時間復雜度、空間復雜度的相關資料,需要的朋友可以參考下2022-03-03