关于spring:Spring框架系列2-Spring简单例子引入Spring要点

上文中咱们简略介绍了Spring和Spring Framework的组件，那么这些Spring Framework组件是如何配合工作的呢？本文次要承接上文，向你展现Spring Framework组件的典型利用场景和基于这个场景设计出的简略案例，并以此引出Spring的外围要点，比方IOC和AOP等；在此基础上还引入了不同的配置形式，如XML，Java配置和注解形式的差别。@pdai

Spring框架系列(2) - Spring简略例子引入Spring要点
- Spring框架如何利用
- 设计一个Spring的Hello World
- 这个例子体现了Spring的哪些外围要点
  - 管制反转 - IOC
  - 面向切面 - AOP
- Spring框架设计如何逐渐简化开发的
  - Java 配置形式革新
  - 注解配置形式革新
  - SpringBoot托管配置
  - 联合Spring历史版本和SpringBoot看倒退
- 更多文章

Spring框架如何利用

上文中，咱们展现了Spring和Spring Framework的组件, 这里对于开发者来说有几个问题：
首先，对于Spring进阶，间接去看IOC和AOP，存在一个断层，所以须要整体上构建对Spring框架认知上进一步深刻，这样能力构建常识体系。
其次，很多开发者入门都是从Spring Boot开始的，他对Spring整体框架底层，以及倒退历史不是很理解；特地是对于一些老旧我的项目保护和底层bug剖析没有全局观。
再者，Spring代表的是一种框架设计理念，须要全局上了解Spring Framework组件是如何配合工作的，须要了解它设计的初衷和将来趋势。

如下是官网在解释Spring框架的罕用场景的图

我加上一些正文后，是比拟好了解的；引入这个图，重要的起因是为前面设计一个案例帮忙你构建认知。

设计一个Spring的Hello World

联合下面的应用场景，设计一个查问用户的案例的两个需要，来看Spring框架帮咱们简化了什么开发工作:
查问用户数据 - 来看DAO+POJO-> Service 的初始化和装载。
给所有Service的查询方法记录日志

创立一个Maven的Java我的项目

引入Spring框架的POM依赖，以及查看这些依赖之间的关系

<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0"         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">    <modelVersion>4.0.0</modelVersion>    <groupId>tech.pdai</groupId>    <artifactId>001-spring-framework-demo-helloworld-xml</artifactId>    <version>1.0-SNAPSHOT</version>    <properties>        <maven.compiler.source>8</maven.compiler.source>        <maven.compiler.target>8</maven.compiler.target>        <spring.version>5.3.9</spring.version>        <aspectjweaver.version>1.9.6</aspectjweaver.version>    </properties>    <dependencies>        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-context</artifactId>            <version>${spring.version}</version>        </dependency>        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-core</artifactId>            <version>${spring.version}</version>        </dependency>        <dependency>            <groupId>org.springframework</groupId>            <artifactId>spring-beans</artifactId>            <version>${spring.version}</version>        </dependency>        <dependency>            <groupId>org.aspectj</groupId>            <artifactId>aspectjweaver</artifactId>            <version>${aspectjweaver.version}</version>        </dependency>    </dependencies></project>

POJO - User

package tech.pdai.springframework.entity;/** * @author pdai */public class User {    /**     * user's name.     */    private String name;    /**     * user's age.     */    private int age;    /**     * init.     *     * @param name name     * @param age  age     */    public User(String name, int age) {        this.name = name;        this.age = 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;    }}

DAO 获取 POJO， UserDaoServiceImpl (mock 数据)

package tech.pdai.springframework.dao;import java.util.Collections;import java.util.List;import tech.pdai.springframework.entity.User;/** * @author pdai */public class UserDaoImpl {    /**     * init.     */    public UserDaoImpl() {    }    /**     * mocked to find user list.     *     * @return user list     */    public List<User> findUserList() {        return Collections.singletonList(new User("pdai", 18));    }}

并减少daos.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="userDao" class="tech.pdai.springframework.dao.UserDaoImpl">        <!-- additional collaborators and configuration for this bean go here -->    </bean>    <!-- more bean definitions for data access objects go here --></beans>

业务层 UserServiceImpl（调用DAO层）

package tech.pdai.springframework.service;import java.util.List;import tech.pdai.springframework.dao.UserDaoImpl;import tech.pdai.springframework.entity.User;/** * @author pdai */public class UserServiceImpl {    /**     * user dao impl.     */    private UserDaoImpl userDao;    /**     * init.     */    public UserServiceImpl() {    }    /**     * find user list.     *     * @return user list     */    public List<User> findUserList() {        return this.userDao.findUserList();    }    /**     * set dao.     *     * @param userDao user dao     */    public void setUserDao(UserDaoImpl userDao) {        this.userDao = userDao;    }}

并减少services.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">    <!-- services -->    <bean id="userService" class="tech.pdai.springframework.service.UserServiceImpl">        <property name="userDao" ref="userDao"/>        <!-- additional collaborators and configuration for this bean go here -->    </bean>    <!-- more bean definitions for services go here --></beans>

拦挡所有service中的办法，并输入记录

package tech.pdai.springframework.aspect;import java.lang.reflect.Method;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.reflect.MethodSignature;import org.springframework.context.annotation.EnableAspectJAutoProxy;/** * @author pdai */@Aspectpublic class LogAspect {    /**     * aspect for every methods under service package.     */    @Around("execution(* tech.pdai.springframework.service.*.*(..))")    public Object businessService(ProceedingJoinPoint pjp) throws Throwable {        // get attribute through annotation        Method method = ((MethodSignature) pjp.getSignature()).getMethod();        System.out.println("execute method: " + method.getName());        // continue to process        return pjp.proceed();    }}

并减少aspects.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"       xmlns:aop="http://www.springframework.org/schema/aop"       xmlns:context="http://www.springframework.org/schema/context"       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">    <context:component-scan base-package="tech.pdai.springframework" />    <aop:aspectj-autoproxy/>    <bean id="logAspect" class="tech.pdai.springframework.aspect.LogAspect">        <!-- configure properties of aspect here as normal -->    </bean>    <!-- more bean definitions for data access objects go here --></beans>

组装App

package tech.pdai.springframework;import java.util.List;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import tech.pdai.springframework.entity.User;import tech.pdai.springframework.service.UserServiceImpl;/** * @author pdai */public class App {    /**     * main interfaces.     *     * @param args args     */    public static void main(String[] args) {        // create and configure beans        ApplicationContext context =                new ClassPathXmlApplicationContext("aspects.xml", "daos.xml", "services.xml");        // retrieve configured instance        UserServiceImpl service = context.getBean("userService", UserServiceImpl.class);        // use configured instance        List<User> userList = service.findUserList();        // print info from beans        userList.forEach(a -> System.out.println(a.getName() + "," + a.getAge()));    }}

整体构造和运行app

这个例子体现了Spring的哪些外围要点

那么Spring框架帮忙咱们做什么，它体现了什么哪些要点呢?

管制反转 - IOC

来看第一个需要：查问用户（service通过调用dao查问pojo)，实质上如何创立User/Dao/Service等；

如果没有Spring框架，咱们须要本人创立User/Dao/Service等，比方：

UserDaoImpl userDao = new UserDaoImpl();UserSericeImpl userService = new UserServiceImpl();userService.setUserDao(userDao);List<User> userList = userService.findUserList();

有了Spring框架，能够将原有Bean的创立工作转给框架, 须要用时从Bean的容器中获取即可，这样便简化了开发工作

Bean的创立和应用拆散了。

// create and configure beansApplicationContext context =        new ClassPathXmlApplicationContext("aspects.xml", "daos.xml", "services.xml");// retrieve configured instanceUserServiceImpl service = context.getBean("userService", UserServiceImpl.class);// use configured instanceList<User> userList = service.findUserList();

更进一步，你便能了解为何会有如下的知识点了：

Spring框架治理这些Bean的创立工作，即由用户治理Bean转变为框架治理Bean，这个就叫管制反转 - Inversion of Control (IoC)
Spring 框架托管创立的Bean放在哪里呢？这便是IoC Container;
Spring 框架为了更好让用户配置Bean，必然会引入不同形式来配置Bean？这便是xml配置，Java配置，注解配置等反对
Spring 框架既然接管了Bean的生成，必然须要治理整个Bean的生命周期等；
利用程序代码从Ioc Container中获取依赖的Bean，注入到应用程序中，这个过程叫 依赖注入(Dependency Injection，DI) ；所以说管制反转是通过依赖注入实现的，其实它们是同一个概念的不同角度形容。艰深来说就是IoC是设计思维，DI是实现形式
在依赖注入时，有哪些形式呢？这就是结构器形式，@Autowired, @Resource, @Qualifier... 同时Bean之间存在依赖（可能存在先后顺序问题，以及循环依赖问题等）

这边引入咱们后续的相干文章：Spring根底 - Spring之管制反转(IOC)

面向切面 - AOP

来看第二个需要：给Service所有办法调用增加日志（调用办法时)，实质上是解耦问题；

如果没有Spring框架，咱们须要在每个service的办法中都增加记录日志的办法，比方：

/*** find user list.** @return user list*/public List<User> findUserList() {    System.out.println("execute method findUserList");    return this.userDao.findUserList();}

有了Spring框架，通过@Aspect注解定义了切面，这个切面中定义了拦挡所有service中的办法，并记录日志；能够显著看到，框架将日志记录和业务需要的代码解耦了，不再是侵入式的了

/*** aspect for every methods under service package.*/@Around("execution(* tech.pdai.springframework.service.*.*(..))")public Object businessService(ProceedingJoinPoint pjp) throws Throwable {    // get attribute through annotation    Method method = ((MethodSignature) pjp.getSignature()).getMethod();    System.out.println("execute method: " + method.getName());    // continue to process    return pjp.proceed();}

更进一步，你便能了解为何会有如下的知识点了：

Spring 框架通过定义切面, 通过拦挡切点实现了不同业务模块的解耦，这个就叫面向切面编程 - Aspect Oriented Programming (AOP)
为什么@Aspect注解应用的是aspectj的jar包呢？这就引出了Aspect4J和Spring AOP的历史渊源，只有了解了Aspect4J和Spring的渊源能力了解有些注解上的兼容设计
如何反对更多拦挡形式来实现解耦，以满足更多场景需要呢？这就是@Around, @Pointcut... 等的设计
那么Spring框架又是如何实现AOP的呢？这就引入代理技术，分动态代理和动静代理，动静代理又蕴含JDK代理和CGLIB代理等

这边引入咱们后续的相干文章：Spring根底 - Spring之面向切面编程(AOP)

Spring框架设计如何逐渐简化开发的

通过上述的框架介绍和例子，曾经初步晓得了Spring设计的两个大的要点：IOC和AOP；从框架的设计角度而言，更为重要的是简化开发，比方提供更为便捷的配置Bean的形式，直至0配置（即约定大于配置）。这里我将通过Spring历史版本的倒退，和SpringBoot的推出等，来帮你了解Spring框架是如何逐渐简化开发的。

Java 配置形式革新

在前文的例子中，通过xml配置形式实现的，这种形式实际上比拟麻烦；我通过Java配置进行革新：

User，UserDaoImpl, UserServiceImpl，LogAspect不必改
将原通过.xml配置转换为Java配置

package tech.pdai.springframework.config;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.EnableAspectJAutoProxy;import tech.pdai.springframework.aspect.LogAspect;import tech.pdai.springframework.dao.UserDaoImpl;import tech.pdai.springframework.service.UserServiceImpl;/** * @author pdai */@EnableAspectJAutoProxy@Configurationpublic class BeansConfig {    /**     * @return user dao     */    @Bean("userDao")    public UserDaoImpl userDao() {        return new UserDaoImpl();    }    /**     * @return user service     */    @Bean("userService")    public UserServiceImpl userService() {        UserServiceImpl userService = new UserServiceImpl();        userService.setUserDao(userDao());        return userService;    }    /**     * @return log aspect     */    @Bean("logAspect")    public LogAspect logAspect() {        return new LogAspect();    }}

在App中加载BeansConfig的配置

package tech.pdai.springframework;import java.util.List;import org.springframework.context.annotation.AnnotationConfigApplicationContext;import tech.pdai.springframework.config.BeansConfig;import tech.pdai.springframework.entity.User;import tech.pdai.springframework.service.UserServiceImpl;/** * @author pdai */public class App {    /**     * main interfaces.     *     * @param args args     */    public static void main(String[] args) {        // create and configure beans        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeansConfig.class);        // retrieve configured instance        UserServiceImpl service = context.getBean("userService", UserServiceImpl.class);        // use configured instance        List<User> userList = service.findUserList();        // print info from beans        userList.forEach(a -> System.out.println(a.getName() + "," + a.getAge()));    }}

整体构造和运行app

注解配置形式革新

更进一步，Java 5开始提供注解反对，Spring 2.5 开始齐全反对基于注解的配置并且也反对JSR250 注解。在Spring后续的版本倒退偏向于通过注解和Java配置联合应用.

BeanConfig 不再须要Java配置

package tech.pdai.springframework.config;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.ComponentScans;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.EnableAspectJAutoProxy;/** * @author pdai */@Configuration@EnableAspectJAutoProxypublic class BeansConfig {}

UserDaoImpl 减少了 @Repository注解

/** * @author pdai */@Repositorypublic class UserDaoImpl {    /**     * mocked to find user list.     *     * @return user list     */    public List<User> findUserList() {        return Collections.singletonList(new User("pdai", 18));    }}

UserServiceImpl 减少了@Service 注解，并通过@Autowired注入userDao.

/** * @author pdai */@Servicepublic class UserServiceImpl {    /**     * user dao impl.     */    @Autowired    private UserDaoImpl userDao;    /**     * find user list.     *     * @return user list     */    public List<User> findUserList() {        return userDao.findUserList();    }}

在App中扫描tech.pdai.springframework包

package tech.pdai.springframework;import java.util.List;import org.springframework.context.annotation.AnnotationConfigApplicationContext;import tech.pdai.springframework.entity.User;import tech.pdai.springframework.service.UserServiceImpl;/** * @author pdai */public class App {    /**     * main interfaces.     *     * @param args args     */    public static void main(String[] args) {        // create and configure beans        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(                "tech.pdai.springframework");        // retrieve configured instance        UserServiceImpl service = context.getBean(UserServiceImpl.class);        // use configured instance        List<User> userList = service.findUserList();        // print info from beans        userList.forEach(a -> System.out.println(a.getName() + "," + a.getAge()));    }}

整体构造和运行app

SpringBoot托管配置

Springboot实际上通过约定大于配置的形式，应用xx-starter对立的对Bean进行默认初始化，用户只须要很少的配置就能够进行开发了。

这个因为很多开发者都是从SpringBoot开始着手开发的，所以这个比拟好了解。咱们须要的是将知识点都串联起来，构筑认知体系。

联合Spring历史版本和SpringBoot看倒退

最初联合Spring历史版本总结下它的倒退：

（这样是不是可能帮忙你在整体上构建了常识体系的认知了呢？）

PS：相干代码，能够通过这里间接查看