深入学习Spring框架（一）- 入门

我就是我 2021-12-07 14:13 336阅读 0赞

# 1.Spring是什么？ #

Spring是一个JavaEE轻量级的一站式开发框架。  
　　　　JavaEE： 就是用于开发B/S的程序。（企业级）  
　　　　轻量级：使用最少代码启动框架，然后根据你的需求选择，选择你喜欢的模块使用。  
　　　　重量级：早期有的EJB，开发一个HelloWorld程序都需要引入EBJ的全部模块  
　　　　一站式：Spring框架提供涵盖了JavaEE开发的表示层，服务层，持久层的所有组件功能。也就是说，原则上，学完一套Spring框架，不用其他框架就可以完成网站一条流程的开发。但是Spring仍然可以和其他的框架无缝整合。

# 2.Spring的优点 #

**轻量：**Spring 是轻量的，就是除内核模块（4个jar），其他模块由开发者自由选择使用，同时支持整合其他框架。也可以称为就是可插拔式开发框架，像插头和插座一样，插上就用。这就是Spring框架核心理念（Ioc）。  
　　**控制反转：**Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。  
　　**面向切面的编程(AOP)：**Spring支持面向切面的编程，并且把应用业务逻辑和系统服务分开。  
　　**容器：**Spring 包含并管理应用中对象的生命周期和配置。  
　　**MVC框架：**Spring的WEB框架是个精心设计的框架，是Web框架的一个很好的替代品。  
　　**事务管理：**Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。  
　　**异常处理：**Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO抛出的）转化为一致的unchecked 异常。

# 3.Spring的作用 #

Spring强调的理念是，轻量级。Spring的轻量级主要体现在模块的可插拔，Spring提供的功能模块，除了内核模块以外，开发人员可以选择性使用。所以，Spring框架在现实开发中，主要的功能用于整合各种开发框架开发项目。

# 4.Spring框架包 #

Spring官方网站：https://spring.io/

## 　　4.1 下载 ##

Spring官方提供的Maven方式的项目下载：https://start.spring.io/  
　　但是基于简单入门的原则，我们要通过导入包的方式来学习。需要下载框架的zip包  
　　地址为：http://repo.springsource.org/libs-release-local/org/springframework/spring/

## 　　4.2 目录说明 ##

根目录：

![1664032-20190709102712304-1225208522.png][]

jar包：

![1664032-20190709102754627-626525313.png][]

包说明：

<table> 
 <tbody> 
  <tr> 
   <td>包名</td> 
   <td>说明</td> 
  </tr> 
  <tr> 
   <td>spring-aop-4.3.2.RELEASE.jar</td> 
   <td>实现了AOP的支持</td> 
  </tr> 
  <tr> 
   <td>spring-aspects-4.3.2.RELEASE.jar</td> 
   <td>AOP框架aspects支持包</td> 
  </tr> 
  <tr> 
   <td><span style="color:#ff0000;">spring-beans-4.3.2.RELEASE.jar</span></td> 
   <td><span style="color:#ff0000;">内核支撑包，实现了处理基于xml对象存取</span></td> 
  </tr> 
  <tr> 
   <td><span style="color:#ff0000;">spring-context-4.3.2.RELEASE.jar&nbsp;</span></td> 
   <td><span style="color:#ff0000;">内核支撑包，实现了Spring对象容器</span></td> 
  </tr> 
  <tr> 
   <td>spring-context-support-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>容器操作扩展包，扩展了一些常用的容器对象的设置功能</td> 
  </tr> 
  <tr> 
   <td><span style="color:#ff0000;">spring-core-4.3.2.RELEASE.jar&nbsp;</span></td> 
   <td><span style="color:#ff0000;">内核支撑包，Spring的内核</span></td> 
  </tr> 
  <tr> 
   <td><span style="color:#ff0000;">spring-expression-4.3.2.RELEASE.jar&nbsp;</span></td> 
   <td><span style="color:#ff0000;">内核支撑包，实现了xml对Spring表达式的支持</span></td> 
  </tr> 
  <tr> 
   <td>spring-instrument-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>提供了一些类加载的的工具类</td> 
  </tr> 
  <tr> 
   <td>spring-instrument-tomcat-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>提供了一些tomcat类加载的的工具类，实现对应Tomcat服务的调用</td> 
  </tr> 
  <tr> 
   <td>spring-jdbc-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>SpringJDBC实现包，一个操作数据库持久层的子框架</td> 
  </tr> 
  <tr> 
   <td>spring-jms-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>集成jms的支持，jms：Java消息服务。</td> 
  </tr> 
  <tr> 
   <td>spring-messaging-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>集成messaging api和消息协议提供支持</td> 
  </tr> 
  <tr> 
   <td>spring-orm-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>ORM框架集成包，实现了Hibernate，IBatis，JDO的集成。</td> 
  </tr> 
  <tr> 
   <td>spring-oxm-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>Spring OXM对主流O/X Mapping框架做了一个统一的抽象和封装。就是对应XML读写框架的支持</td> 
  </tr> 
  <tr> 
   <td>spring-test-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>Spring集成JUnit测试</td> 
  </tr> 
  <tr> 
   <td>spring-tx-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>事务代理的支持</td> 
  </tr> 
  <tr> 
   <td>spring-web-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>SpringWeb通用模块</td> 
  </tr> 
  <tr> 
   <td>spring-webmvc-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>SpringMVC子框架</td> 
  </tr> 
  <tr> 
   <td>spring-webmvc-portlet-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>Spring对门户技术（portlet）的支持</td> 
  </tr> 
  <tr> 
   <td>spring-websocket-4.3.2.RELEASE.jar&nbsp;</td> 
   <td>Spring对websocket的支持</td> 
  </tr> 
 </tbody> 
</table>

注：红色部分为基础核心包，使用Spring必须导入

# 5.入门实例 #

Spring之所以可以实现模块的可插拔是支持依赖注入，所谓的依赖注入/控制反转就是不用new就可以创建对象。

使用Spring框架不用new创建一个对象：

1.创建项目并导入jar包：将Spring的基础支撑包和依赖的日志包复制到lib文件下，并且加入项目中

![1664032-20190709103910438-436643496.png][]

2.创建配置文件  
　　在项目的src下面创建配置文件applicationContext.xml中并完成配置文件的约束

3.创建对象到Spring容器中  
　　创建一个类

package com.gjs.service;
    
    public class HelloSpringService {
        public void say() {
            System.out.println("你好！Spring");
        }
    }

往applicationContext.xml配置文件中加入配置

测试类， 使用getBean方法获得容器中的对象。

package com.gjs.test;
    
    import static org.junit.Assert.*;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.gjs.service.HelloSpringService;
    
    public class TestSpring {
        @Test
        public void testName() throws Exception {
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            HelloSpringService helloSpringService = context.getBean("HelloSpringService",HelloSpringService.class);
            helloSpringService.say();
        }
    }

# 6.Spring容器的两个实现 #

ClassPathXmlApplicationContext:通过classpath路径（相对路径）直接获得加载的xml文件（推荐使用）

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

FileSystemXmlApplicationContext：通过文件路径（绝对路径）来获得加载的xml文件。

ApplicationContext context = new FileSystemXmlApplicationContext("D:\\java\\eclipse-workspace\\spring1\\src\\applicationContext.xml");

# 8.控制反转（IOC）和依赖注入（DI）（A） #

## 　　DI：Dependency Injection（依赖注入）： ##

依赖注入是指Spring创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设值给该对象。

## 　　IoC：Inverse of Control（控制反转）: ##

Spring号称是一个可以实现模块可插拔的JavaEE开发框架。而实现程序可插拔的核心理念就是控制反转。所谓的控制反转，就是将代码的调用权从调用方转移给被调用方（服务提供方）。不用修改调用方的的代码，只要修改配置文件就实现对象的切换。  
　　读作“反转控制”，更好理解，它不是什么技术，而是一种设计思想，好比于MVC。就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。  
　　正控：若调用者需要使用某个对象，其自身就得负责该对象的创建。  
　　反控：调用者只管负责从Spring容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了Spring框架。  
　　控制反转（Ioc），就是依赖注入加上面向接口的编程思想的实现

## 　　示例： ##

整体结构：

![1664032-20190709104502940-2084027594.png][]

CustomService接口：

package com.gjs.service;
    
    public interface CustomeService {
        public void say();
    }

实现类CustomServiceImpl1：

package com.gjs.service.impl;
    
    import com.gjs.service.CustomeService;
    
    public class CustomServiceImpl1 implements CustomeService {
    
        @Override
        public void say() {
            System.out.println("CustomerServiceImpl1.say()");
        }
    }

实现类CustomServiceImpl2：

package com.gjs.service.impl;
    
    import com.gjs.service.CustomeService;
    
    public class CustomServiceImpl2 implements CustomeService {
    
        @Override
        public void say() {
            System.out.println("CustomerServiceImpl2.say()");
        }
    }

调用方 CustomClient：

package com.gjs.client;
    
    import com.gjs.service.CustomeService;
    
    public class CustomClient {
        //1.声明一个接口引用类型
        private CustomeService customeService;
        //2.spring的依赖注入（DI）需要有一个set方法
        public void setCustomeService(CustomeService customeService) {
            this.customeService = customeService;
        }
        
        public void say() {
            customeService.say();
        }
    }

配置文件 applicationContext.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">
               
            <bean id="client" class="com.gjs.client.CustomClient">
                
                <property name="customeService" ref="ServiceImpl1"/>
            </bean>
            
            <bean id="ServiceImpl1" class="com.gjs.service.impl.CustomServiceImpl1"/>
            <bean id="ServiceImpl2" class="com.gjs.service.impl.CustomServiceImpl2"/>    
    </beans>

测试类：

package com.gjs.test;
    
    import static org.junit.Assert.*;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.gjs.client.CustomClient;
    import com.gjs.service.CustomeService;
    
    public class TestSpring {
        @Test
        public void testName() throws Exception {
            //1.读取配置文件，创建Spring容器
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            //获取调用方 CustomClient对象
            CustomClient client = context.getBean("client", CustomClient.class);
            //调用CustomClient对象的say()方法
            client.say();
        }
    }

## 　　应用： ##

Spring框架又被称为容器框架，即通过控制反转将各个框架的对象创建交给Spring管理，然后通过依赖注入在层之间传递参数整合框架，并达到低耦合的目的。

![1664032-20190709104759581-1777705469.png][]

# 9.标签说明 #

## 　　9.1 bean标签 ##

作用：用于声明一个类,在启动Spring框架的时候根据该配置的类创建对象到容器里面

id：设置对象名（唯一标识符）（推荐使用）  
name:设置对象名（唯一标识符）,与id的区别是可以有多个名称,每个名称用逗号隔开。  
class:指定对象对应的类  
scope:用于设置的对象的作用范围，可选参数如下：

![1664032-20190709105001354-1269201921.png][]

在Web开发的三层架构中的使用  
　　Web层：一般都是多例  
　　Service层 ：单例  
　　DAO层 ：单例

## 　　9.2 alias 别名标签　　 ##

作用：为已配置的bean设置别名

bean id="user" name="test" class="com.gjs.pojo.User"/>
    <alias name="user" alias="user1"/>

name:必要属性, 代表为哪一个bean配置别名, 此属性的值为其他bean标签的id或name属性值  
alias: 必要属性,命名的别名

# 10.实例化Bean的四种方式 #

1.构造器实例化（无参数构造器）：（最常用）

public class SomeBean {
        public SomeBean() {
            System.out.println("SomeBean.SomeBean()");
        }
    }

2.通过静态方法工厂创建（C）

public class SomeBean {
        public SomeBean() {
            System.out.println("SomeBean.SomeBean()");
        }
    }
    public class SomeBeanFacotry {
        //静态工厂方法
        public static SomeBean getSomeBean() {
            System.out.println("执行静态工厂方法");
            return new SomeBean();
        }
    }

3.通过实体工厂创建（C）

public class SomeBean {
        public SomeBean() {
            System.out.println("SomeBean.SomeBean()");
        }
    }
    public class SomeBeanFacotry {
        //实例工厂方法
        public SomeBean getSomeBean() {
            System.out.println("执行实例工厂方法");
            return new SomeBean();
        }
    }

或

4.实现FactoryBean接口实例化：实例工厂变种  
　　实现FactoryBean接口,MyBatis和Spring集成就是使用的这种方式。此种方式，如果没有使用Bean对应的对象，Spring就不会自动创建，只有在使用的时候Spring才会创建对应的对象

public class SomeBean {
        public SomeBean() {
            System.out.println("SomeBean4.SomeBean4()");
        }
    }
    public class SomeBeanObjectFactory implements FactoryBean<SomeBean>{
        //返回的泛型类型对应的对象
        @Override
        public SomeBean getObject() throws Exception {
            SomeBean bean = new SomeBean();
            return bean;
        }
    }

# 11.初始化和销毁方法 #

init-method：bean生命周期初始化方法,对象创建后就进行调用  
　　destroy-method:容器被销毁的时候，如果bean被容器管理，会调用该方法。

# 12.依赖注入的四种方法 #

1.setter注入，（属性注入）（常用）

使用setter注入：

1，使用bean元素的<property>子元素设置；

1.简单类型值，直接使用value赋值；  
2.引用类型，使用ref赋值；  
3.集合类型，直接使用对应的集合类型元素即可。

2，spring通过属性的set方法注入值；  
3，在配置文件中配置的值都是string，spring可以自动的完成类型的转换

示例：

员工类

public class Employee {
        private Integer age;
        private String name;
        private Department dept;
        public Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Department getDept() {
            return dept;
        }
        public void setDept(Department dept) {
            this.dept = dept;
        }
        @Override
        public String toString() {
            return "Employee [age=" + age + ", name=" + name + ", dept=" + dept + "]";
        }    
    }

部门类

public class Department {
        private Integer id;
        private String name;
        public Integer getId() {
            return id;
        }
        public void setId(Integer id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }

配置文件

2.构造器注入

使用bean元素的<constructor-arg>子元素设置:

1.默认情况下，constructor-arg的顺序就是构造器参数的顺序  
2. constructor-arg的属性

name ： 构造方法参数的名称  
index ：参数的位置从 0 开始  
value ：值类型注入  
ref ：引用类型注入  
type : 参数的数据类型

3.一般在一个类必须依赖另一个类才能正常运行时，才用构造器注入

3.p命名空间注入

使用p命名空间注入先在约束上面引入 p标签  
　　xmlns:p="http://www.springframework.org/schema/p"

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:p="http://www.springframework.org/schema/p"
        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">
            
         
         <bean id="department" class="com.gjs.pojo.Department" 
         p:id="3"
         p:name="销售部"/>
         
         
         <bean id="emp" class="com.gjs.pojo.Employee" 
         p:id="1"
         p:name="张三"
         p:dept-ref="department"/>
    </beans>

4.集合类型值注入  
用于处理：  
　　1.键值对 Map 、Properties  
　　2.数组  
　　3.集合Set、List

public class CollectionBean {
        private Set<String> set;
        private List<String> list;
        private String[] array;
        private Map<String, String> map;
        private Properties prop; //读取本地 xxx.properties文件(本质就是一个Map集合)
    }

<?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">
            
         <bean id="collectionBean" class="cn.zj.spring.pojo.CollectionBean">
             
             
             
             <property name="arr">
                 <array>
                     <value>AAA</value>
                     <value>BBB</value>
                 </array>
             </property>
             
             
             <property name="set" >
                 <set>
                     <value>AAA</value>
                     <value>AAA</value>
                     <value>BBB</value>
                 </set>
             </property>
             
             
             <property name="lsit">
                 <list>
                     <value>list1</value>
                     <value>list1</value>
                     <value>list2</value>
                 </list>
             </property>
             
             <property name="map">
                 <map>
                     <entry key="key1" value="value1"/>
                     <entry key="key2" value="value2"/>
                 </map>
             </property>
             
             <property name="prop">
                 <props>
                     <prop key="propKey1">propValue1</prop>
                     <prop key="propKey2">propValue2</prop>
                 </props>
             </property>
         </bean> 
    </beans>

# 13.获得properties文件的值 #

1.导入命名空间方法  
　　将命名空间和约束重新拷贝一份,将对于的全部替换成 context,然后关联context本地schema约束

2.导入Mysql驱动包和druid连接池jar包

![1664032-20190709110456307-1805632746.png][]

3.applicationContext.xml配置

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:p="http://www.springframework.org/schema/p"
        xmlns:context="http://www.springframework.org/schema/context"
        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
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
            ">
            
          
          <context:property-placeholder location="classpath:db.properties"/>
              
              <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" 
                  init-method="init" destroy-method="close"
              >
                  
                  <property name="driverClassName" value="${jdbc.driverClassName}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
                
                <property name="maxActive" value="${jdbc.maxActive}"/>
          </bean>
      
    </beans>

测试代码

@Test
        public void testSave() throws Exception {
            ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
            
            DataSource dataSource = context.getBean(DataSource.class, "dataSource");
            Connection conn = dataSource.getConnection();
            System.out.println("数据库连接对象:"+conn);
        }

转载于:https://www.cnblogs.com/gaojinshun/p/11156030.html

[1664032-20190709102712304-1225208522.png]: /images/20211207/213113ef72cf47c28d9d0095a9d42877.png
[1664032-20190709102754627-626525313.png]: /images/20211207/5154006849e048df867a7604c6904332.png
[1664032-20190709103910438-436643496.png]: /images/20211207/729a68f7aeda4a9493caa1b618848163.png
[1664032-20190709104502940-2084027594.png]: /images/20211207/29086627d3b24f63ab8e2cb81f5549c3.png
[1664032-20190709104759581-1777705469.png]: /images/20211207/cfb42851a63c4f72b4fa84f4a10c0bf3.png
[1664032-20190709105001354-1269201921.png]: /images/20211207/0875a1831e5f415eb1429d3601d2b635.png
[1664032-20190709110456307-1805632746.png]: /images/20211207/28e30626bb7c476c825b79d16b086613.png