Spring入门

一、Spring

官网：https://spring.io

优秀的java开源框架。

作用：项目管理。 管理组件(对象 DAO，Service，Controller)。

设计思路：践行工厂模式，打造一个工厂，通过工厂完成对项目的管理。

学习思路：分析项目中的问题，引入spring解决方案，打造更好的项目形态。

二、spring工厂搭建

1.导入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>4.3.6.RELEASE</version>
</dependency>

spring 核心jar，其中核心容器 jar：beans、context、context-support、core、expression

2.配置文件
配置文件作用：描述哪些组件需要spring生产，管理
文件配置：resources目录
文件名称：随意。常用名：applicationContext.xml beans.xml

下面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">
    <!-- 作用：声明需要spring 生产的组件 -->
    <!-- UserDAOImpl组件  id="组件标识" class="组件类型" -->
    <bean id="userDAO" class="com.zhj.dao.UserDAOImpl"></bean>
    <!-- UserServiceImpl组件 -->
    <bean id="userService" class="com.zhj.service.UserServiceImpl"></bean>
    ....
</beans>

3.启动工厂

工厂接口：ApplicationContext
实现类：ClassPathXmlApplicationContext

// 启动工厂，注意：需要指定配置文件位置
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
// 从工厂中获取 标识为"userDAO"的组件
UserDAO userDAO = (UserDAO)context.getBean("userDAO")

三、Spring-Schema

Schema:配置文件的schema（规范）

作用:统一配置格式，开发者和框架采用同一套配置语法。向框架传达开发意图。

格式：xsd文件 （spring-beans-4.1.xsd，spring-context-4.1.xsd，…）

导入方式：spring的每种schema都有namespace作为标识；

：在配置文件中追加namespace，以及和namespace配套的location即可。如下：

<beans xmlns="http://www.springframework.org/schema/beans"  <!-- beans-Schema的ns -->
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans   
                           <!-- beans-Schema的location -->
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
	...
</beans>

每种schema中，都在定义：允许出现那些标签，标签的层级，标签的先后顺序，标签的属性。每一种配制意图，都有规范中的标签、属性来描述。

四、项目中的问题

1. 依赖关系

项目由一个个的组件组成，而组件之间都不是孤立的。会彼此依赖。

2. 强耦合

类之间的关系紧密程度，即耦合度。关系松散即弱耦合，关系密切即强耦合。

class A{
    public void eat(){...}
}
class B{
    public void fn2(Dog a){a.eat();...}
}
//如上B类中 直接关联了A类，则B类智能和A类协作，不能和其他类协作 ==> 强耦合

interface A{ public void eat();}
class B implements A{
    public void fn1(){...}
}
class Test{
 	public void fn2(IA a){a.fn1();...}   
}
//如上B类中只是和IA接口关联，则此时B类可以使用A类，也可以在完全不需要改动的情况下兼容所有IA的其他实现类。
//则B类 和 A类 的关系是松散的 ==> 弱耦合

关系处理不当时，可能会导致组件之间强耦合。

一旦强耦合：组件即陷入`不稳健`的状态，`不稳健`的组件 将导致整个项目的形态极差。

项目中的具体体现：Controller 依赖 Service 、Service 依赖 DAO 、....

# 五、解决方案

spring介入后，可以以全新的方式处理依赖关系，`既保证依赖健全，又没有强耦合。`

<?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">
    <!-- 作用：声明需要spring 生产的组件 -->
    <!-- UserDAOImpl组件  id="组件标识" class="组件类型" -->
    <bean id="userDao" class="com.zf.dao.UserDaoImpl">

    </bean>
    <!-- UserServiceImpl组件 -->
    <bean id="userService" class="com.zf.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
        <!--给不同类型数据赋值-->
    <bean id="TestInput" class="com.zf.pojo.TestInput">
        <property name="id" value="1"></property>
        <property name="name" value="徐明"></property>
        <property name="list">
            <list>
                <value>子枫</value>
                <ref bean="userService"></ref>
            </list>
        </property>
        <property name="properties">
            <props>
                <prop key="战士">怒巴尔</prop>
            </props>
        </property>
        <property name="userDaoimpl" ref="userDao"></property>
    </bean>
    <bean id="myFactory" class="com.zf.pojo.MyFactory"></bean>
    <bean id="myFactory1" class="com.zf.pojo.MyFactory2" factory-method="builderSqlSessionFactory"></bean>
    <bean id="service" class="com.zf.pojo.TestInput">
    </bean>
    <bean id="testInput" class="com.zf.pojo.TestInput">
        <property name="date">
            <bean factory-bean="dateFormater" factory-method="parse">
                <constructor-arg value="2019-8-9"></constructor-arg>
            </bean>
        </property>
    </bean>
    <bean id="dateFormater" class="java.text.SimpleDateFormat">
        <constructor-arg name="pattern" value="yyyy-MM-dd"></constructor-arg>
    </bean>

</beans>

UserService.java
属性注入即通过setXxx()方法注入Bean的属性值或依赖对象，由于属性注入方式具有可选择性和灵活性高的优点，因此属性注入是实际应用中最常采用的注入方式。

属性注入要求Bean提供一个默认的构造函数，并为需要注入的属性提供对应的Setter方法。Spring先调用Bean的默认构造函数实例化Bean对象，然后通过反射的方式调用Setter方法注入属性值。

import com.zf.dao.UserDao;

public class UserServiceImpl implements UserService {
    //private UserDAO userDAO = new UserDAOImpl(); 不再强耦合UserDAOImpl 
    private UserDao userDao;//替换为接口，但这时要提供get()和set()方法。

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void insert() {
        System.out.println("userservice .........................");
        userDao.insert();
    }
}

此时UserServiceImpl和UserDaoImpl就是弱耦合关系。所以使用spring可以保证依赖健全，又没有强耦合。