spring教程（一）：簡單實現

本文轉載自查看原文 2018-02-01 15:17 12020 spring/ frame

一、概念介紹

1. 一站式框架：管理項目中的對象。spring框架性質是容器（對象容器）

2. 核心是控制反轉（IOC）和面向切面（AOP）

IOC：反轉控制--將創建對象的方式反轉

自己創建、維護對象-->由spring完成創建、注入

反轉控制就是反轉了對象的創建方式，從自己創建反轉給了程序

DI：依賴注入--實現IOC需要DI做支持

注入方式：set、構造方法、字段注入

注入類型：值類型（8大數據類型）、引用類型（對象）注入

二、簡單實現

1.導包

首先根據圖找到需要的jar包，再導入日志包

導入包后項目結構如圖所示

2.創建一個對象 bean

 1 package com.dic.bean;
 2 
 3 public class User {
 4     
 5     private String name;
 6     private String age;
 7     
 8     
 9     public String getName() {
10         return name;
11     }
12     public void setName(String name) {
13         this.name = name;
14     }
15     public String getAge() {
16         return age;
17     }
18     public void setAge(String age) {
19         this.age = age;
20     }
21 
22 }

User.xml

3.配置核心 xml 文件

對名字、位置沒有具體要求，一般命名為 applicationContext.xml 放置在 src 下

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" 
 3 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">
 4 
 5 
 6     <!-- 將user對象交給spring -->
 7     <!-- 
 8         name:調用時用的名字
 9         class：路徑
10     -->
11        <bean name="user" class="com.dic.bean.User"></bean>
12         
13        
14 </beans>

applicationContext.xml

4. junit 測試以下代碼，控制台打印不為空且無報錯即為成功

 1 package com.dic.text;
 2 
 3 import org.junit.Test;
 4 import org.springframework.context.ApplicationContext;
 5 import org.springframework.context.support.ClassPathXmlApplicationContext;
 6 
 7 import com.dic.bean.User;
 8 
 9 public class Demo1 {
10     
11     @Test
12     public void fun1(){
13         
14         //1 創建容器對象
15         ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
16         //2 向容器"要"user對象
17         User u = (User) ac.getBean("user");
18         //3 打印user對象
19         System.out.println(u);
20         
21         
22     }
23 
24 }

Demo1.java

三、<bean>元素詳解注釋都寫在代碼里，也可以直接看第四部分

1. 元素解釋

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


    <!-- bean元素：使用該元素描述需要spring容器管理的對象 -->
    <!-- 
        name:調用時用的名字
        class：路徑
        id：與name屬性作用一樣但名稱不可重復且不能使用特殊字符
        scope屬性：
            singleton（默認值）：單例對象，在spring容器中啟動時創建，只存在一個
            prototype：多例原型，每次在獲得時才會創建，每次都創建一個新的
    -->
    <bean name="user" class="com.dic.bean.User></bean>

</beans>

2. 模塊化配置：即將bean分散在多個文件中配置，在 applicationContext.xml 中添加一句引用即可

<!-- 導入其他spring配置文件 -->
<import resource="com/dic/bean/applicationContext.xml"/>

3. 屬性注入之 set 注入

分為 set 注入、對象注入兩種，在 xml 中注入內容如下

<!-- set注入  -->
     <bean name="user1" class="com.dic.bean.User1">
           <property name="name" value="tom"></property>
           <property name="age" value="18"></property>
     </bean>
     
  
<!-- 對象注入 -->
     <!-- 1. -->
     <bean name="car" class="com.dic.bean.Car">
           <property name="name" value="的健康的"></property>
           <property name="color" value="yellow"></property>
     </bean>
     <!-- 2. -->
     <bean name="user2" class="com.dic.bean.User2">
           <property name="name" value="tom"></property>
           <property name="age" value="18"></property>
           <property name="Car" ref="car"></property>
     </bean>

4. 屬性注入之構造方式注入

1. 在 User3.java 中添加構造方法

public User3(String name, Car car) {
    System.out.println("構造方式");
    this.name = name;
    this.car = car;
}

2. 在 applicationContext.xml 中添加配置注意賦值標簽不一樣

     <!-- 構造方法注入    -->
     <bean name="user3" class="com.dic.bean.User3">
           <constructor-arg name="name" value="嗯哼"></constructor-arg>
           <constructor-arg name="car" ref="car"></constructor-arg>
      </bean>

構造方式注意：出現同名參數時指定參數類型

<bean name="user3" class="com.dic.bean.User3">
           <!-- 出現同名參數 用type指定參數類型即可  -->
           <constructor-arg name="name" value="11" type="java.lang.Integer"></constructor-arg>
           <constructor-arg name="car" ref="car"></constructor-arg>
      </bean>

5. 復雜類型注入

復雜的類型注入，如：數組、list、map、properties

 1      <!-- 復雜類型注入  使用set方式   -->
 2   
 3          <bean name="user4" class="com.dic.bean.User4">
 4              <!-- array -->
 5                  <!-- 如果數組中只有一個值，也可使用 name value   -->
 6                  <property name="arr">
 7                      <array>
 8                          <value>tom</value>
 9                          <value>jerry</value>
10                          <ref bean="user2"/>
11                      </array>
12                  </property>           
13              <!-- list -->
14                  <property name="list">
15                      <list>
16                          <value>jack</value>
17                          <value>rose</value>
18                          <ref bean="user2" />
19                      </list>
20                  </property>     
21              <!-- map -->
22                  <property name="map">
23                      <map>
24                         <entry key="url" value="jdbc:mysql:///crm" ></entry>
25                         <entry key="user" value-ref="user"  ></entry>
26                         <entry key-ref="user3" value-ref="user2"  ></entry>
27                      </map>
28                  </property>
29              <!-- pro -->
30                  <property name="pro">
31                      <props>
32                         <prop key="driverClass">com.jdbc.mysql.Driver</prop>
33                         <prop key="userName">root</prop>
34                         <prop key="password">root</prop>
35                     </props>
36                  </property>
37          </bean>

四、代碼整理

 1 package com.dic.bean;
 2 
 3 public class Car {
 4     
 5     private String name;
 6     private String color;
 7     
 8     public String getName() {
 9         return name;
10     }
11     public void setName(String name) {
12         this.name = name;
13     }
14     public String getColor() {
15         return color;
16     }
17     public void setColor(String color) {
18         this.color = color;
19     }
20 
21 }

Car.java

 1 package com.dic.bean;
 2 
 3 public class User {
 4     
 5     private String name;
 6     private String age;
 7     
 8     
 9     public String getName() {
10         return name;
11     }
12     public void setName(String name) {
13         this.name = name;
14     }
15     public String getAge() {
16         return age;
17     }
18     public void setAge(String age) {
19         this.age = age;
20     }
21 
22 }

User.java

package com.dic.bean;

public class User1 {
    
    private String name;
    private String age;
    
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }

}

User1.java

 1 package com.dic.bean;
 2 
 3 public class User2 {
 4     
 5     private String name;
 6     private String age;
 7     private Car car;
 8     
 9     
10     public String getName() {
11         return name;
12     }
13     public void setName(String name) {
14         this.name = name;
15     }
16     public String getAge() {
17         return age;
18     }
19     public void setAge(String age) {
20         this.age = age;
21     }
22     public Car getCar() {
23         return car;
24     }
25     public void setCar(Car car) {
26         this.car = car;
27     }
28 
29 }

User2.java

 1 package com.dic.bean;
 2 
 3 public class User3 {
 4     
 5     private String name;
 6     private String age;
 7     private Car car;
 8     
 9     
10     public User3(String name, Car car) {
11         System.out.println("構造方式");
12         this.name = name;
13         this.car = car;
14     }
15     
16     
17     //出現同參數名 
18     public User3(Integer name, Car car) {
19         System.out.println("同名參數構造方式");
20         this.name = name+"";
21         this.car = car;
22     }
23 
24 }

User3.java

 1 package com.dic.bean;
 2 
 3 import java.util.List;
 4 import java.util.Map;
 5 import java.util.Properties;
 6 
 7 public class User4 {
 8     
 9     private Object[] arr; 
10     private List list;
11     private Map map;
12     private Properties pro;  //實際上就是一個map
13     
14     
15     
16     public Object[] getArr() {
17         return arr;
18     }
19     public void setArr(Object[] arr) {
20         this.arr = arr;
21     }
22     public List getList() {
23         return list;
24     }
25     public void setList(List list) {
26         this.list = list;
27     }
28     public Map getMap() {
29         return map;
30     }
31     public void setMap(Map map) {
32         this.map = map;
33     }
34     public Properties getPro() {
35         return pro;
36     }
37     public void setPro(Properties pro) {
38         this.pro = pro;
39     }
40 
41     
42 }

User4.java

 1 package com.dic.text;
 2 
 3 import org.junit.Test;
 4 import org.springframework.context.ApplicationContext;
 5 import org.springframework.context.support.ClassPathXmlApplicationContext;
 6 
 7 import com.dic.bean.User;
 8 import com.dic.bean.User1;
 9 import com.dic.bean.User2;
10 import com.dic.bean.User3;
11 
12 public class Demo1 {
13     
14     @Test
15     public void fun1(){
16         
17         //1 創建容器對象
18         ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
19         //2 向容器"要"user對象
20         User u = (User) ac.getBean("user");
21         //3 打印user對象
22         System.out.println(u);
23         
24         User1 u1 = (User1) ac.getBean("user1");
25         System.out.println(u1);
26         
27         User2 u2 = (User2) ac.getBean("user2");
28         System.out.println(u2);
29         
30         
31         User3 u3 = (User3) ac.getBean("user3");
32         System.out.println(u3);
33         
34     }
35 
36 }

Demo1.java

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" 
 3 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd ">
 4 
 5 
 6     <!-- bean元素：使用該元素描述需要spring容器管理的對象 -->
 7     <!-- 
 8         name:調用時用的名字
 9         class：路徑
10         id：與name屬性作用一樣但名稱不可重復且不能使用特殊字符
11         scope屬性：
12             singleton（默認值）：單例對象，在spring容器中啟動時創建，只存在一個
13             prototype：多例原型，每次在獲得時才會創建，每次都創建一個新的
14     -->
15     <bean name="user" class="com.dic.bean.User"></bean>
16     
17     
18     <!-- set注入  -->
19        <bean name="user1" class="com.dic.bean.User1">
20            <property name="name" value="tom"></property>
21            <property name="age" value="18"></property>
22        </bean>
23        
24     <!-- 對象注入 -->
25        <!-- 1. -->
26        <bean name="car" class="com.dic.bean.Car">
27            <property name="name" value="的健康的"></property>
28            <property name="color" value="yellow"></property>
29        </bean>
30        <!-- 2. -->
31        <bean name="user2" class="com.dic.bean.User2">
32            <property name="name" value="tom"></property>
33            <property name="age" value="18"></property>
34            <property name="Car" ref="car"></property>
35        </bean>
36        
37        
38      <!-- 構造方法注入    -->
39         <bean name="user3" class="com.dic.bean.User3">
40            <!-- 出現同名參數 用type指定參數類型即可  -->
41            <constructor-arg name="name" value="11" type="java.lang.Integer"></constructor-arg>
42            <constructor-arg name="car" ref="car"></constructor-arg>
43         </bean>
44        
45        
46      <!-- 復雜類型注入  使用set方式   -->
47   
48          <bean name="user4" class="com.dic.bean.User4">
49              <!-- array -->
50                  <!-- 如果數組中只有一個值，也可使用 name value   -->
51                  <property name="arr">
52                      <array>
53                          <value>tom</value>
54                          <value>jerry</value>
55                          <ref bean="user2"/>
56                      </array>
57                  </property>           
58              <!-- list -->
59                  <property name="list">
60                      <list>
61                          <value>jack</value>
62                          <value>rose</value>
63                          <ref bean="user2" />
64                      </list>
65                  </property>     
66              <!-- map -->
67                  <property name="map">
68                      <map>
69                         <entry key="url" value="jdbc:mysql:///crm" ></entry>
70                         <entry key="user" value-ref="user"  ></entry>
71                         <entry key-ref="user3" value-ref="user2"  ></entry>
72                      </map>
73                  </property>
74              <!-- pro -->
75                  <property name="pro">
76                      <props>
77                         <prop key="driverClass">com.jdbc.mysql.Driver</prop>
78                         <prop key="userName">root</prop>
79                         <prop key="password">root</prop>
80                     </props>
81                  </property>
82          </bean>
83     
84     
85     
86     
87     <!-- 導入其他配置文件
88            <import resource="com/dic/bean/applicationContext.xml"/>
89        -->
90        
91 </beans>

applicationContext.xml

免責聲明！

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

猜您在找 spring security簡單教程以及實現完全前后端分離 Spring-Security教程【一】簡單的登錄認證 Spring Cloud簡單入門教程 spring使用@Cache的簡單實現 Spring MVC 關於分頁的簡單實現 Spring Boot -- Spring AOP原理及簡單實現 Spring Aop實現簡單代碼實現 spring MVC 簡單實現及原理分析 Spring Boot實現簡單的Token登錄驗證簡單實現Spring中BeanFactory原理