Spring入门---几分钟带你了解Spring框架

---

一、什么是Spring

Spring是一个分层的Java SE/EE full-stack（一站式）轻量级开源框架，以IoC（Inverse Of Control：控制反转）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

在java三层架构当中分别提供了相应技术：

IOC容器:整个项目，所有的对象都交给IOC

表现层（web层） ：SpringMVC 框架

业务层（service层） ：AOP(日志记录，事务…)

持久层（dao层） ：JdbcTemplate模板对象以及提供了ORM模块整合其他优秀的持久层技术

---

二、Spring的优势是什么

• 方便解耦，简化开发 :Spring 就是一个大工厂，可以管理所有对象的创建和依赖关系维护，交给Spring管理

• AOP 编程的支持 ：可以方便的实现对程序进行权限拦截，日志记录，运行的监控

• 声明式事务的支持 ：通过配置方式完成对事务的管理，无需手动编程

• 方便程序的测试 ：对Junit支持，可以通过注解方便的对Spring程序进行测试

• 整合外部优秀技术 ： Spring内部提供了对各种优秀框架（Hibernate，Mybatis，Quartz等）的直接支持

• javaEE技术的封装 ：Spring对javaEE开发当中复杂难用的API（JavaEmail, RMI等）进行封装，降低了这些API的使用难度

---

三、Spring体系结构

如果作为一个整体，这些模块为你提供了开发企业应用所需的一切。但你不必将应用完全基于Spring框架。你可以自由地挑选适合你的应用的模块而忽略其余的模块。

---

四、什么是IOC

IOC：Inverse Of Control 控制反转
简单来说就是把复杂系统分解成相互合作的对象，这些对象类通过封装以后，内部实现对外部是透明的，从而降低了解决问题的复杂度，而且可以灵活地被重用和扩展

重点：借助第三方工具实现具有依赖关系对象之间的解耦

---

五、怎么搭建SringIOC

随意准备两个实体类：phone1、phone2

public class Phone1{
    private String name;
    
    public void send(){
        System.out.println("phone1发送了");
    }
    public void call(){
        System.out.println("phone1呼叫了");
    }
}

public class Phone2 {
    private String name;

    public void send(){
        System.out.println("phone2发送了");
    }
    public void call(){
        System.out.println("phone2呼叫了");
    }
}

1、导入依赖

在pom.xml文件下添加

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.17.RELEASE</version>
    </dependency>
</dependencies>

2、创建Spring配置文件，将实体类（bean）托管到Spring

新建一个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
        https://www.springframework.org/schema/beans/spring-beans.xsd">


    <!-- 把HuaWei、Mi 交给spring 创建
        class  完全限定名 (包名 + 类名)
        id     在spring容器中的唯一标志,id属性值不能相同
     -->
    <bean class="com.entity.phone1" id="phone1"></bean>
    <bean class="com.entity.phone2" id="phone2"></bean>
</beans>

3、使用ClassPathXmlApplicationContext对象解析配置文件、getBean方法获取对象

 @Test
    //测试从spring获取手机
    //由spring来负责各个对象的创建。
    //测试类不需要手动创建Phone2 、Phone1，从而降低耦合度
    public void test(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Phone1 phone1= (phone1) context.getBean("phone1");
        Phone1.send();
        Phone2 phone2= (Phone2 ) context.getBean("phone2");
        phone2.call();
    }

---

六、什么是依赖注入

依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。

简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取

---

七、Spring的几种依赖注入方式

随便建一个实体类：Person

public class Person {

    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show(){
        System.out.println("我的名字叫"+name+",今年我"+age+"岁");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

1、通过set方法

在applicationContext.xml文件下

<!--    调用无参构造方法-->
 <!-- 依赖注入 -->
    <bean class="com.entity.Person" id="person">
        <!-- 使用setter方法注入 -->
        <property name="name" value="小红"></property>
        <property name="age" value="18"></property>
    </bean>

测试

 @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person");
        person.show();
    }

运行结果

2、通过构造方法

在applicationContext.xml文件下

 <!-- 依赖注入 -->
    <bean class="com.ujiuye.demo3.Person" id="person">
       <!-- 第二种依赖注入的方式，通过构造方法进行赋值
            属性name  ：  构造方法中参数的名字
            属性value ：  需要注入的数据
            属性index ：  指定参数的索引 索引从0开始算
            属性type  ：  指定参数的类型
  -->
        <constructor-arg type="java.lang.String" index="0" name="name" value="小绿"></constructor-arg>
        <constructor-arg type="int" index="1" name="age" value="9"></constructor-arg>
      
    </bean>

测试

 @Test
    public void test(){

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person");
        person.show();
    }

运行结果

3、注解注入

---

八、Spring模块化配置

为什么需要模块化，因为如果一个applicationContext配置文件里面包含所有的bean，会让applicationContext很臃肿，即让这个文件数据变得庞大，又影响后期维护，所以，Spring提供了多配置文件的方式：

1、并列多个配置文件

在创建ApplicationContext对象的时候，直接传入多个配置文件

ApplicationContext act = new ClassPathXmlApplicationContext("beans1.xml","beans2.xml","...");

2、主从配置文件

先配置一个主配置文件(一般为applicationContext.xml文件)，然后在里面导入其它的配置文件

<import resource="beans1.xml" />
<import resource="beans2.xml" />