Spring入门学习笔记

简介

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

1、优点

Spring是一个开源的免费的框架（容器）
Spring是一个轻量级的、非入侵式的框架，对原来的项目影响非常小；
控制反转（IOC），面向切面编程（AOP）
支持事务的处理，对框架整合的支持

总结一句话：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！

2、组成

3、拓展

SpringBoot：
- 一个快速开发的脚手架；
- 基于SpringBoot可以快速的开发单个服务；
- 约定大于配置
SpringCloud：
- SpringCloud是基于SpringBoot实现的；

因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC。承上启下的作用。
弊端：发展了太久之后违背了原来的理念！配置十分繁琐，人称：“配置地狱”

IOC本质

控制反转IoC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现IoC的一种方法，也有人认为DI只是IOC 的另一种说法。没有IOC的程序中，我们使用面向对象编程，对象的创建与对象简单的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方。
个人认为所谓控制反转就是：==获得依赖对象的方式反转了==。采用XML配置Bean的时候，Bean的定义信息和实现是分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到零配置的目的。控制反转是一种通过描述（XML或者注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入（dependency Injection，DI）；

全面支持Java 8.0

1、Spring中的数据转换框架

@DateTimeFormat

 @GetMapping("/testdate/{date}")
@ResponseBody
public JSONResponse testDate(
    @RequestParam("date")
    @DateTimeFormat(pattern = "yyyy-MM-dd",iso = DateTimeFormat.ISO.DATE) 
    String date){
        System.out.println(date);
        return JSONResponse.ok();
    }

如果格式不对，会返回400错误；

可以在resourse/templates/error中自定义400.html页面

  <!DOCTYPE html>
  <html lang="en">
  <head>
      <meta charset="UTF-8">
      <title>Title</title>
  </head>
  <body>
  <pre style="word-wrap: break-word; white-space: pre-wrap;">{code:400,msg:"日期参数格式错误",data:null}</pre>
  </body>
  </html>

@DateTimeFormat不生效的原因：只能接收 @RequestParam数据

2、重复注解支持

Java 8.0增加了对重复注解的支持，Spring 4.0也同样支持。目前Spring4.0仅支持对注解
@Scheduled和@PropertySource的重复。例如：可以在一个类中使用多个@PropertySource注解来加载不同的资源配置文件。

@Configuration
@ComponentScan
@EnableAutoConfiguration
@PropertySource("classpath:/confl.properties")
@PropertySource("classpath:/conf2.properties")
public class Application {
    @Autowired
    private Environment env;

    @Bean
    public MyBean getBean() {
        return new MyBean(env.getProperty("appl.p1"), env.getProperty("app2.p1"));
    }

    public static void main(String[] args) {
        SpringApplication.run(AppServer.class, args);
    }
}

3、空指针终结者

核心容器的增强

支持泛型依赖注入
@Lazy:延迟依赖注入
- ```
  @Lazy
  @Service
  public class UserServiceImpl implements UserService{
      ...
  }
```
- 也可以把@Lazy放在@Autowired之上，即依赖注入也是掩饰的，当调用userService时才会注入。同样适用于@Bean;
List注入
- ```
  @Autowired
  private List<BaseService> Bean;
```
- 这样会注入所有实现了BaseService的Bean，但顺序是不确定的。在Spring4.0中可以使用@Order或Ordered接口来实现排序。
  - ```
    @Order(value=1)
    @Service
    public class UserService extends BaseService<User>{
    	...
    }
```
其他：

Spring子项目（红色字体为未校对）

子项目名称	子项目介绍
Spring IO Platform	SpringIO是可集成的、构建现代化应用的版本平台。SpringIO是模块化的、企业级的分布式系统，包括一系列依赖，使得开发者仅能对自己所需的部分进行完全的部署控制;
Spring Boot	Spring 应用快速开发工具，用来简化Spring应用开发过程
Spring XD	Spring XD ( eXtreme Data 极限数据)是Pivotal的大数据产品。它结合了SpringBoot和Grails组成Spring IO平台的执行部分
Spring Cloud	==Spring Cloud 为开发者提供了在分布式系统（如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性Token、全局锁、决策竞选、分布式会话和集群状态）中操作的开发工具。使用Spring Cloud，开发者可以快速实现上述这些模式==
Spring Data	==Spring Data是为了简化构建基于Spring框架应用的数据访问实现，包括非关系数据库、Map-Reduce框架、云数据服务等；另外，也包含对关系数据库的访问支持==
Spring Integration	==Spring Integration为企业数据集成提供了各种适配器，可以通过这些适配器来转换各种消息格式，并帮助Spring应用完成与企业应用系统的集成==
Spring Batch	==Spring Batch是一个轻量级的完整批处理框架，旨在帮助应用开发者构建一个健壮、高效的企业级批处理应用（这些应用的特点是不需要与用户交互，重复的操作量大，对于大容量的批量数据处理而言，这些操作往往要求较高的可靠性）==
Spring Security	==Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用Spring loC和AOP功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作==
Spring Hatecoas	==Spring Hateoas是一个用于支持实现超文本驱动的REST Web服务的开发库，是Hateoas的实现。Hateoas（Hypermedia as the engine of application state）是REST架构风格中最复杂的约束，也是构建成熟REST服务的核心。它的重要性在于打破了客户端和服务器之间严格的契约，使得客户端可以更加智能和自适应，而REST服务本身的演化和更新也变得更加容易==
Spring Social	==Spring Social 是Spring框架的扩展，用来方便开发Web社交应用程序，可通过该项目来创建与各种社交网站的交互，如Twitter、Facebook、Linkedln和Triplt等==
Spring AMQP	==Spring AMQP是基于Spring框架的AMQP消息解决方案，提供模板化的发送和接收消息的抽象层，提供基于消息驱动的POJO。这个项目支持Java和.NET两个版本。Spring Source旗下的Rabbit MQ（Erlang语言开发）就是一个开源的基于AMQP的消息服务器==
Spring for Android	==Spring for Android为Android终端开发应用提供Spring的支持，它提供了一个在Android应用环境中工作、基于Java的REST客户端==
Spring Mobile	==Spring Mobile 是基于Spring MVC构建的，为移动终端的服务器应用开发提供支持。比如，使用Spring Mobile可以在服务器端自动识别连接到服务器的移动终端的相关设备信息，从而为特定的移动终端实现应用定制==
Spring Web Flow	==Spring Web Flow（SWF）一个建立在Spring MVC基础上的Web页面流引擎。随着其自身项目的发展，Web Flow比原来更为丰富，SWF定义了一种特定的语言来描述页面流。其目标是成为管理Web应用页面流程的最佳方案。当你的应用需要复杂的导航控制，如向导，在一个比较大的事务过程中指导用户经过一连串的步骤的时候，SWF是一个很好的解决方案框架==
Spring Web Services	==Spring Web Services（Spring WS）是基于Spring框架的Web服务框架，主要侧重于基于文档驱动的Web服务，提供SOAP服务开发，允许通过多种方式创建Web服务==
Spring LDAP	==Spring LDAP是一个用于操作LDAP的Java框架，类似于Spring JDBC提供了Jdbc Template方式来操作数据库。这个框架提供了一个Ldap Templater 操作模板，可帮助开发人员简化looking up、closing contexts、encoding/decoding values、filters等操作==
Spring Session	==Spring Session 致力于提供一个公共基础设施会话，支持从任意环境中访问一个会话。在Web环境下支持独立于容器的集群会话，支持可插拔策略来确定Session ID，WebSocket活跃的时候可以简单地保持HttpSession==
Spring Shell	==Spring Shel提供交互式的Shell，用户可使用简单的基于Spring的编程模型来开发命令==

如何获取Spring

在pom.xml中配置Spring依赖

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

Spring Hello

1、Hello 对象由谁创建？

hello对象由Spring创建。

2、Hello对象的属性怎么设置？

hello对象的属性由Spring容器设置。

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">
  ...
</beans>

3、这个过程就叫控制反转：

控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的；
反转：程序本身不创建对象，而变成被动的接收对象. 依赖注入：就是利用set方法来进行注入的；
依赖注入：就是利用set方法来进行注入的；

4、IOC是一种编程思想，由主动的编程变成被动的接收.

5、可以通过new ClassPathXmlApplicationContext去浏览一下底层源码.

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

<bean id="mysqlImp1" class="com.kuang.dao.UserDaomysqlImp1"/>
<bean id="oracleImp1" class="com.kuang.dao.UserDaooracleImp1"/>
<bean id="UserServiceImp1" class="com.kuang.service.UserServiceImp1">  
    <property name="userDao" ref="oracleImp1"/>
    <!--
		ref:引用Spring容器中创建好的对象；
  		value:具体的值，基本数据类型；
	-->
</bean>

快速入门

1、Maven

1.1、Maven模型图

1.2、Maven的基础概念

Project：任何你想构建的事务，Maven都可以认为他们是工程。这些工程被定义为工程对象模型（Project Object Model ，POM）。一个工程可以依赖其他的工程，一个工程也可以由多个子工程构成。
POM：POM（pom.xml）是Maven的核心文件，它是指示Maven如何工作的元数据文件，类似于Ant中的build.xml文件。POM文件位于每个工程的根目录中。
GroupId：Groupld是一个工程在全局中的唯一标识符，一般地，它就是工程名。Groupld 有利于使用一个完全的包名将一个工程从其他有类似名称的工程中区别出来。
Artifact：中文名为“构件”，是工程将要产生或需要使用的文件，它可以是.jar文件、源文件、二进制文件、.war文件，甚至是.pom文件。每个Artifact都由Groupld和Artifactld组合的标识符唯一识别。需要被使用的Artifact 都要放在仓库（见Repository）中，否则Maven无法找到它们。
Dependency：为了能够构建或运行，一个典型的Java工程会依赖其他的包。在Maven中，这些被依赖的包就被称为Dependency。Dependency一般是其他工程的Artifact。
Plug-in：可以说Maven就是一堆插件的集合，它的每一个功能都是由插件完成的。插件提供goal（类似于Ant中的target），并根据在POM中找到的元数据去完成工作。主要的Maven插件是由Java编写而成的，同时支持用Beanshell或Ant脚本编写的插件。
Repository：仓库，即放置Artifact的地方，有中央仓库、公共仓库、私有仓库及本地仓库之分。为了提高Artifact的下载速度，一般情况下，公司或开发者组织都需要部署一个私有仓库，可使用Nexus（http://www.sonatype.org/nexus）创建Maven私有仓库。

2、创建库表

drop database if exists sampledb;
create DATABASE sampledb DEFAULT CHARACTER set utf8;
USE sampledb;
-- 创建用户表
create table t_user{
    user_id INT AUTO_INCREMENT PRIMARY KEY,
    user_name VARCHAR(30),
    credits int,
    password varchar(32),
    last_visit datetime,
    last_ip varchar(23)
}ENGINE=InnoDB;
-- 创建用户登录日志表
create table t_login_log{
	login_log_id int AUTO_INCREMENT PRIMARY KEY,
	user_id int;
    ip varchar(23),
    login_datetime datetime
}ENGINE=InnoDB;

3、初始化数据

INSERT INTO t_user (user_name,password)VALUES('admin','123456');

IOC创建对象的方式

（一）创建Bean

1.使用无参构造创建对象，默认；

2.假设我们使用有参构造创建对象;

1)通过下标创建

<bean id="exampleBean" class="examples.ExampleBean">              
    <constructor-arg index="0" value="7500000"/>              
    <constructor-arg index="1" value="42"/>          
</bean>

2）通过类型创建（不建议使用）

<bean id="exampleBean" class="examples.ExampleBean">              
 <constructor-arg type="int" value="7500000"/>              
 <constructor-arg type="java.lang.String" value="42"/>          
</bean>

3）通过参数名设置

<bean id="exampleBean" class="examples.ExampleBean">              
      <constructor-arg name="years" value="7500000"/>              
      <constructor-arg name="ultimateAnswer" value="42"/>          
</bean>

3、总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！

（二）Spring配置

1、别名

<bean id="user" class="com.hubz.pojo.User" >
	<constructor-arg type="java.lang.String" value="鸡蛋"/>
</bean>

<alias name="user" alias="userNew"/>

2、Bean配置

<!-- 
	id: bean的唯一标识符，也相当于我们学的对象名
    class: bean对象的全限定名: 包名+类名
	name: 别名，而且 name 可以同时取多个别名
-->
<bean id="user" class="com.hubz.pojo.User" name="u1 u2,u3;u4" >
	<constructor-arg type="java.lang.String" value="鸡蛋"/>
</bean>

3、import

这个import一般用于团队开发使用，他可以将多个配置文件，导入合并为一个；
假设，现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的Bean中，我们可以利用import将所有人的bean.xml合并为一个总的。
- 张三
- 李四
- 王五
- 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">

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


</beans>

使用的时候直接使用总的就可以了，别名以及其他也会合并

(三) 依赖注入

1、构造器注入

public class UserServiceImpl implents UserService{
    private UserDao userDao;

    @Autowire
    public UserServiceImpl(UserDao userDao){
        this.userDao = userDao;
    }
}

2、Set注入

public class UserServiceImpl implents UserService{
    private UserDao userDao;

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

依赖注入：Set注入
- 依赖：bean对象的创建依赖于容器；
- 注入：bean对象的所有属性，由容器来注入；

3、基于字段的注入

【环境搭建】

复杂类型

Student.java

import java.util.*;

public class Student {
    private String name;
    private Address address;
    private String[] strings;
    private List<String> list;
    private Map<String,String> map;
    private Set<String> set;
    private String wife;
    private Properties info;

}

Address.java

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

beans.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="address" class="com.hubz.pojo.Address">
        <property name="address" value="上海" />
    </bean>

    <bean id="student" class="com.hubz.pojo.Student">
        <!--第一种：普通值注入，value-->
        <property name="name" value="东方"/>

        <!--引用-->
        <property name="address" ref="address"/>

        <!--数组-->
        <property name="books" >
            <array>
                <value>三国演义</value>
                <value>水浒传</value>
                <value>西游记</value>
                <value>红楼梦</value>
            </array>
        </property>
        <!--List-->
        <property name="list">
            <list>
                <value>看书</value>
                <value>写作</value>
            </list>
        </property>
        <!--Map-->
        <property name="map">
            <map>
                <entry key="身份证" value="47864512165"/>
                <entry key="考号" value="325453156452"/>
            </map>
        </property>

        <property name="set">
            <set>
                <value>hahah</value>
                <value>Test</value>
            </set>
        </property>

        <property name="wife">
            <null/>
        </property>

        <property name="info">
            <props>
                <prop key="driver">Driver</prop>
                <prop key="url">小明</prop>
                <prop key="root">郝仁</prop>
                <prop key="password">123456</prop>
            </props>
        </property>
    </bean>
</beans>

真实测试对象

测试类

import com.hubz.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new 
            ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.getName());
    }
}

4、拓展方式注入

p命名空间:添加

xmlns:p="http://www.springframework.org/schema/p"

c命名空间：添加

xmlns:c="http://www.springframework.org/schema/c"

使用

User.java

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

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

    public User() {}

 	 ...

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

userbeans.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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--p命名空间注入，可以直接注入属性值： property-->
    <bean id="user" class="com.hubz.pojo.User" p:name="东方" p:age="20"/>


    <!--c命名空间注入，通过构造器注入：construct-args ：： 必须有有参构造器-->
    <bean id="user2" class="com.hubz.pojo.User" c:name="狂神" c:age="18"/>

</beans>

MyTest.java

import com.hubz.pojo.Student;
import com.hubz.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void test2(){
        ApplicationContext context = new 
            ClassPathXmlApplicationContext("userbeans.xml");
        User user = context.getBean("user",User.class);
        System.out.println(user.toString());

        User user2 = context.getBean("user2",User.class);
        System.out.println(user2.toString());
    }
}

注意点：p命名空间和c命名空间不能直接使用，需要导入xml约束

(四) Bean作用域

1582362435200

1、单例模式

示意图:

写法：（Spring 默认机制）

<bean id="user2" class="com.hubz.pojo.User" 
      c:name="狂神" c:age="18" 
      scope="singleton"
/>

2、原型模式

示意图

写法：（每次从容器中get时都会产生一个新对象）

<bean id="user2" class="com.hubz.pojo.User"
      c:name="狂神" c:age="18"
      scope="prototype"
/>

3、其余模式

其余的request、session、application这些只能在web开发中用到

(五) Bean的自动装配

自动装配是Spring满足Bean依赖的一种方式；
Spring会在上下文中自动寻找，并自动给Bean装配属性；

Spring有三种装配的方式

在xml中显式的装配
在Java中显式的装配
隐式的自动装配【重要】

1、测试

环境搭建：一个人有两个宠物

2、自动装配

byName

<bean id="cat" class="com.hubz.pojo.Cat"/>
<bean id="dog" class="com.hubz.pojo.Dog"/>

<!--
    byName: 会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid
        理解： 根据成员变量 自动查找相对应的（和变量名相同的）bean id；
    -->
<bean id="people" class="com.hubz.pojo.People" autowire="byName">
    <property name="name" value="张亮"/>
</bean>

byType

<bean id="cat" class="com.hubz.pojo.Cat"/>
<bean  class="com.hubz.pojo.Dog"/>
<!--<bean id="dog1" class="com.hubz.pojo.Dog"/>-->


<!--
        byType:会自动在容器上下文中查找，和自己对象属性类型相同的bean；
            弊端：当存在俩个相同类型时会报错，必须类型唯一；
    -->
<bean id="people" class="com.hubz.pojo.People" autowire="byType">
    <property name="name" value="张亮"/>
</bean>

小结
- byName的时候，需要保证所有的bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致。
- byType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型值一致。

3、使用注解实现自动装配

jdk1.5支持的注解，Spring2.5就支持注解了！

The introduction of annotation-based configurations raised the question of whether this approach is 'better' than XML.

使用注解须知：

导入约束：

xmlns:context="http://www.springframework.org/schema/context"

配置注解的支持：
```
<context:annotation-config/>
```

<?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"
	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:annotation-config/>

</beans>

@Autowired

public class People {
    @Autowired
    private Dog dog;

    private Cat cat;
    private String name;

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public Cat getCat() {
        return cat;
    }

    @Autowired
    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "People{" +
                "dog=" + dog +
                ", cat=" + cat +
                ", name='" + name + '\'' +
                '}';
    }
}

直接在属性上使用即可！也可在set方式上使用！
使用@Autowired我们不用编写Set方法了，前提是你这个自动装配的属性在IOC（Spring）容器中存在，且符合名字byName；

科普：

@Nullable     //字段标记了这个注解，说明这个字段可以为null

public class People {
    @Autowired
    private Dog dog;

    @Autowired
    //在有多个配置的情况下，不使用这个会发生找不到的情况
    //作用就是唯一指定
    @Qualifier(value="cat111")
    private Cat cat;
    private String name;

    //参数可以为空，而不报错
    public People(@Nullable Cat cat) {
        this.cat = cat;
    }
}

如果@Autowired自动装配环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value=“xxx”)去配置@Autowired的使用，指定一个唯一的Bean对象注入。

<!--自动装配环境比较复杂的情况 -->
<bean id="dog111" class="com.hubz.pojo.Dog"/>
<bean id="dog11" class="com.hubz.pojo.Dog"/>

@Resource

public class People {
    @Resource
    private Dog dog;

    /**
     * @Resource：
     *  先找和变量名字一样的，有则注入；
     *  没有则按照类型查找：
     *      如果只有一个同类型，注入；
     *      如果有多个同类型，报错；
     *  都没找到：
     *      报错
     *
     * 可以指定查找：指定查找也只能有一个，不知为何？
     */
    @Resource(name = "cat1")
    private Cat cat;
}

4、小结：

@Resource和@Autowired的区别

都是用来自动装配，都可以放在属性字段上。
@ Autowired 通过byType的方式实现，而且必须要求这个对现存在！【常用】
@ Resource 默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！
执行顺序不同：
- @Resource ：默认通过byName的方式实现
- @Autowired：通过byType的方式实现

(六) Spring 注解开发

在Spring4之后，要使用注解开发，必须要保证aop的包导入了

1582437441837

使用注解需要注解的支持

<?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"
	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:component-scan base-package="com.hubz.pojo"/>
  
	<context:annotation-config/>

</beans>

1、Bean

@Component

该组件放在类上，说明这个类被Spring管理了，就是bean

2、属性如何注入

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

// 等价于<bean id="user" class="com.hubz.pojo.User"/>
// @Component :组件
@Component
public class User {

    // public String name = "东方";

    // 相当于<property name="name" value="xiaoxiao"/>
    // 简单的使用Value，复杂的建议使用配置文件
    // @Value("dongdong") //可以放在这，也可以放在set上
    public String name;

    @Value("dongdong")
    public void setName(String name) {
        this.name = name;
    }
}

3、衍生的注解

@Component有几个衍生注解，我们在Web开发中，会按照MVC三层架构分层
- dao 【@Repository】
- service 【@Service】
- controller 【@Controller】

并且让扫描器扫描全局

<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.hubz"/>

这四个注解的功能都是一样的，都代表会将某个类注册到Spring中，装配Bean

4、作用域

@Component
@Scope("prototype")  //一般不用，这个注解都少见
public class User {
	public String name;
}

5、小结

xml与注解

xml更加万能，适用于任何场合，维护起来更加方便；
注解，不是自己类使用不了，维护更加复杂

xml与注解最佳实践

xml用来管理bean
注解只负责完成属性的注入

我们在使用的过程中只需要注意一个问题：必须让注解生效，就需要开启注解的支持

<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.hubz.pojo"/>
<context:annotation-config/>

(七) 使用JavaConfig实现配置

我们现在完全不使用xml，全权交给Java来做！

JavaConfig是Spring的一个子项目，在Spring 4 之后，他成为了一个核心功能！

1582440424071

@Component
public class User {

    @Value("dass")
    public String name;

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

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

//这个注解也是将这个类被Spring托管，注册到容器中，因为他本来就是一个@Component
// @Configuration 代表这是一个配置类，就和我们之前看的beans.xml一样
@Configuration
@ComponentScan("hubz.pojo")
@Import(Config2.class) //引入其他配置类，引成一个类，和beans.xml中的import功能一样
public class HbConfig {

    /**
     * 注册一个bean，就相当于我们之前写的一个bean标签；
     * 这个方法的名字，就相当于bean标签中的id属性
     * 这个方法的返回值，就相当于bean标签中的class属性
     */
    @Bean
    public User getUser(){
        return new User(); //就是返回要注入到bean的对象
    }
}

测试类

import hubz.config.HbConfig;
import hubz.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //如果完全使用了配置类方式去做，我们就只能通过 AnnotationConfig 上下文来获取容器，通过配置类的cLass对象加载！
        ApplicationContext context = new AnnotationConfigApplicationContext(HbConfig.class);
        User user = context.getBean("getUser",User.class);
        System.out.println(user.name);

    }
}

这种纯Java的配置方式，在SpringBoot中随处可见

AOP

1、代理模式

为什么要学代理模式？因为这是SpringAOP的底层！【SpringAOP和SpringMVC】

代理模式的分类;

静态代理
动态代理

1.1、静态代理

角色分析
- 抽象角色：一般会用接口和抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
- 客户：访问代理对象的人
代理模式的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共部分也就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理
代理模式的缺点：
- 一个真实角色就会产生一个代理角色；代码量会翻倍~开发效率会变低
代码步骤：
- 接口
- 真实角色
- 代理角色
- 客户端访问角色

1.2、加深理解

1582711112796

面向对象七大原则：看一看

1.3、动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口：JDK 动态代理【我们在这里使用】
- 基于类：cglib
- Java字节码实现：javasist

需要了解两个类：Proxy：代理；InvocationHandler：调用处理程序

1582762264277

动态代理的好处：

可以使真实角色的操作更加纯粹！不去关注一些公共的业务；
公共也就交给代理角色！实现了业务的分工！
公共业务发生扩展的时候，方便集中管理；
一个动态代理类代理的是一个接口，一般就是对应的一类业务;

2、AOP

2.1、什么是AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发效率。

1582762539834

2.2、AOP在Spring中的作用

==提供声明式事务：允许用户自定义切面==

横切关注点：跨越应用程序多个模块的方法或功能。既是，与我们业务逻辑无关的，但我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等。。。
切面（Aspect）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知的对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的“地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5中类型的Advice：

通知类型	连接点	实现接口
前置通知	方法前	`org.springframework.aop.MethodBeforeAdvice`
后置通知	方法后	`org.springframework.aop.AfterReturningAdvice`
环绕通知	方法前后	`org.aoplliance.intercept.MethodInterceptor`
异常抛出通知	方法抛出异常	`org.springframework.aop.ThrowsAdvice`
引介通知	类中增加新的方法属性	`org.springframework.aop.IntroductionInterceptor`

即AOP在不改变原有代码的情况下，去增加新的功能。

2.3、使用Spring实现AOP

【重点】使用AOP织入，需要导入一个依赖包

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.5</version>
</dependency>

需要了解切入点语法

1582763696296

方式一：使用Spring的API接口【主要SpringAPI接口实现】

方式二：自定义类【主要是切面定义】

方式三：使用注解实现

声明式事务

1、回顾事务

把一组业务当成一个业务来做：要么都成功，要么都失败！
事务在项目开发中十分重要，涉及数据的一致性问题，不能马虎！
确保数据完整性和一致性

2、Spring中的事务管理

声明式事务：AOP
编程式事务：需要在代码中，进行事务的管理【没啥用】

思考：

为什么需要事务？

如果不配置事务，可能存在数据提交不一致问题！
如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务！
事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！