全栈式框架-Spring(上)

---

前言

Spring是分层的JavaSE/EE full-stack 轻量级开源框架，以IOC（Inverse of Control 控制反转）和AOP（Aspect Oriented Programming 面向切面编程）为内核，使用基本的JavaBean来实现程序功能。

---

一、Spring概述

1.1 spring是什么?

spring于2003年兴起的一个轻量级的IOC和AOP的java开发框架,为了简化企业级开发而生

---

1.2 spring有什么优点?

1.轻量级
jar包小,运行消耗内存资源小,核心包小

2.非侵入式
不需要继承 spring 特定的类，通过配置完成依赖注入后就可以使用,不会侵入到我们的业务代码(servlet service dao)

哪种方式是侵入式的?
UserServlet extends HttpServlet
需要继承HttpServlet才能使用,所以是侵入式的

3.IOC
以前我们是怎么创建对象的?
在需要对象的程序代码中手动new一个对象

Inversion of Control,缩写为 IOC,由Spring IOC容器来管理对象,spring理念是将生成对象的控制权反转给spring框架, 由spring框架生成并管理对象

4.AOP
Aspect Oriented Programming 面向切面编程
当我们开发出第一版程序,现在要往程序中加入一个保存日志功能,按照以前的方法应该怎么做?
在程序中调用保存日志的方法,需要修改源代码

AOP的思想是 可以帮我们动态代理的调用,而不需要修改源代码

5.一站式框架
它是一个后端管理架构框架,集基础容器,数据访问(jdbc,事务管理),web(Servlet),AOP 为一身的一站式框架

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

---

1.3 spring的体系结构

Core Container(核心容器)
1.Core模块：提供了框架的基本组成部分，包括控制反转和依赖注入功能。(Spring 核心)
2.Beans模块：提供了BeanFactory，是工厂模式的一个经典实现，Spring将管理对象称为Bean。(管理 Beans)
3.Context模块：配置文件
4.Expression: SpEL 表达式

AOP:面向切面编程

Aspects:AOP框架 允许定义方法拦截器和切入点，将代码按照功能进行分离，以便干净地解耦。

Data Access(数据库整合):JDBC, ORM, OXM, JMS, Transaction

Web(MVC Web 开发): Web, Servlet, Portlet, Struts

Test:支持使用JUnit或TestNG对Spring组件进行单元测试和集成测试。(Junit 整合)

---

二、Spring环境搭建

2.1导入 spring 核心基础 jar

        <!-- spring-context  spring 核心基础 jar-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

2.2编写 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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
        <!--把User对象的控制权交给Spring框架管理-->
       <bean id="user"  class="com.ffyc.spring.bean.User"></bean>
</beans>

2.3编写一个 User 实体类

public class User {
    private  String name;
    private  Integer age;

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    
    public void speak(){
        System.out.println("测试成功了");
    }
 }

2.4测试 spring

public class Test1 {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        User user=applicationContext.getBean("user",User.class);
        user.speak();
    }
}

测试结果

由上图可知,我们成功通过spring框架创建了一个对象,并且调用了这个对象中的方法

---

三、IOC

3.1 IOC概述

Spring将在Java应用中各实例之间的调用关系成为依赖(Dependency)。如果实例A调用实例B的方法,则称A依赖B。
把原本在程序中手动创建对象的控制权交给spring框架来管理,由spring框架生成对象,当我们需要使用的时候直接从 ioc 容器中直接获取的方式称为控制反转(Inversion of Control,IoC)或者依赖注入(Dependency Injection,DI)。

注意:依赖注入和控制反转是对同一件事情的不同描述,前者是后者的一种实现

正控:自己去负责对象的创建
反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象

IOC 容器
具有依赖注入功能的容器,负责对象的实例化,对象的初始化,对象和对象之间依赖关系配置,对象的销毁,对外提供对象的查找等操作,对象的整个生命周期都是由容器来控制。

---

3.2 为什么要使用IOC?

目的:降低耦合度

传统方式:对象和对象之间发生严重的依赖关系，耦合度非常高而且依赖关系都写死在了实现代码里，项目不易修改和维护，必须要改代码。

IOC方式: 我们不再需要自己负责创建对象，管理对象生命周期以及维护对象的依赖关系，这些Spring都替我们完成了。

底层实现方式:
解析 xml/扫描注解标签 + 工厂模式 + 反射机制

---

四、Spring Bean管理

4.1 基于xml配置方式

Spring可以看作一个大型工厂，生产和管理Spring容器中的Bean。如何使用这个工厂生产和管理Bean，需要开发者使用标签将Bean配置在Spring的配置文件中。

<bean id="userDao"  class="com.ffyc.spring.dao.UserDao" scope="prototype">

id 生成的对象名
class 全类名
name 对象别名,可以为多个
scope:
singleton(默认值):在 Spring 中只存在一个 bean 实例, 单例模式.
prototype:原型 getBean()的时候都会 new Bean()

---

4.2 xml配置方式依赖注入

指 Spring 创建对象的过程中，将对象依赖属性（简单值，集合，对象）通 过配置设置给该对象。
实现 IOC 需要 DI 做支持
注入的方式：

构造方法注入

        <bean id="user" name="user1,user2" class="com.ffyc.spring.bean.User" scope="prototype">
            <constructor-arg type="java.lang.String" value="张三"></constructor-arg>
            <constructor-arg type="java.lang.Integer" value="1"></constructor-arg>
        </bean>
        
        <bean id="user" name="user1,user2" class="com.ffyc.spring.bean.User" scope="prototype">
            <constructor-arg name="name" value="张三"></constructor-arg>
            <constructor-arg name="age" value="1"></constructor-arg>
        </bean>

set 方法注入

        <bean id="userDao"  class="com.ffyc.spring.dao.UserDao" scope="prototype"> </bean>

        <bean id="userService"  class="com.ffyc.spring.service.UserService" scope="prototype">
           <property name="userDao" ref="userDao"></property>
        </bean>

---

4.3 注解方式实现

1. 导入Spring aop jar 包

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

2 .开启注解扫描

<context:component-scan base-package="com.ffyc.spring"></context:component-scan>

对整个项目的包开启注解扫描

3 .注解创建对象

常用的标签有
1.@Component(value=“user”)等于

<bean id="user" class=""></bean>

该注解用于向Spring容器中注入一个Bean对象

可以不写value,会默认生成id号

2.@Service :该注解用于标注一个类为业务逻辑类

3.@Repository:该注解用于标注一个类为数据访问类

4.@Controller:该注解用于标注一个类为控制器类

以上注解都可以实现创建对象功能，只是为了后续扩展功能，在不同的层使用不同的注解标记

5.@Scope(value=“prototype”) 原型
@Scope(value=“ singleton ”) 单例

6.@Autowired
写在字段和setter方法上。如果写在字段上，那么就不需要再写 setter 方法。默认情况下它要求依赖对象必须存在， 如果允许 null值，可以设置它的required属性为 false。

注意:该注解默认使用按类型自动装配 Bean 的方式。

如果我们想使用按照名称（byName）来装配，可以结合@Qualifier 注解一起 使用。

7.@Resource:
默认按照 ByName 自动注入,使用时指定其 name 属性，则 name 的值即为按照名称进行匹配 的 Bean 的 id

4.4 注解与 XML 的对比

注解优点： 方便,直观,高效（代码少，没有配置文件的书写那么复杂）。
注解缺点：以硬编码的方式写入到 Java 代码中，修改是需要重新编译代码的。

xml 优点是： 配置和代码是分离的,在 xml 中做修改，无需编译代码，只需重启服务器即可将新的配置加载。
xml 的缺点是：编写麻烦，效率低，大型项目过于复杂。

---

五、Spring JDBC

Spring 是个一站式框架,Spring自身也提供了控制层的SpringMVC和持久层的Spring JdbcTemplate

搭建步骤

1.下载 Spring JdbcTemplate 的 jar 包

        <!-- spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
        <!-- 阿里数据源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

2.导入属性文件

<context:property-placeholder location="config.properties"/>

该属性文件的配置如下

3.管理数据源对象

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${driverClass}"></property>
        <property name="url" value="${jdbcUrl}"></property>
        <property name="username" value="${user}"></property>
        <property name="password" value="${pwd}"></property>
        <property name="initialSize" value="10"></property>
        <property name="maxActive" value="20"></property>
    </bean>

4.在配置文件中创建 JdbcTemplate

    <!-- 配置 spring 事务管理类, 并注入数据源 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

5.在类中注入JdbcTemplate 对象，就可以直接使用。

---

总结

spring框架给java程序员带来了春天。本章主要介绍了spring概述、环境搭建、bean的管理等。本章的重点是几个注解标签的使用,读者需要熟练掌握。在下面的学习中我们还要学习spring框架的内容,包括aop、事务、集成mybatis等。spring的设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣,一定要熟练掌握。

---