Spring教程

一、概念介绍

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>