Spring

简介

Spring 框架是以 interface21框架为基础吗，经过重新设计，并不断丰富其内涵，于2004年3月发布了1.0正式版
Spiring本身是一个大杂烩，整合了现有的技术框架。比如SSH, SSM
Spring是一个轻量级的、非入侵式的框架，核心是控制反转IOC和面向切面编程AOP，支持事务的处理和对框架的支持

组成

Spring 七大模块

IOC

理论推导

首先回顾一下传统的开发，就是一个接口就要有它对应的实现类，然后业务层要调用DAO层的代码，因为要拿到数据库的数据嘛对于业务层来说。
在我们之前的业务代码中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求取修改源代码。如果程序代码量很大，那么修改一次的成本就很高。

我们使用一个Set接口实现，已经发生了革命性的变化

之前，程序主动创建对象，控制权在程序员手上
使用了set注入之后，程序不再具有主动性，而是变成了被动的接受对象。

这种思想让程序员不用管理对象的创建，系统的耦合性降低，可以更加专注在业务的实现上，这是IOC的原型.

1. UserDao接口

public interface UserDao {
    void getUser();
}

2. UserDaoImpl 实现类

public class UserDaoImpl implements UserDao {

    @Override
    public void getUser() {
        System.out.println("默认获取用户的数据");
    }
}

3. UserService 业务接口

public interface UserService {
    void getUser();
}

4. UserServiceImpl 业务实现类

public class UserServiceImpl implements UserService {
    //业务层代码现在要调用dao的代码
    //这个地方的代码每一次需求变动，都得被修改
    private UserDao userDao;

    //现在我们加上一个set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void getUser() {
        userDao.getUser();
    }
}

5. 用户代码

public class MyTest {
    public static void main(String[] args) {

        //用户实际调用的是业务层，dao层他们不需要接触
//        UserService userService = new UserServiceImpl();
//        userService.getUser();

        // 现在需求来了，我要新增一个MysqlDao怎么办
        //这个时候我们就必须去改变业务层调用dao层的代码了

        UserService userService1 = new UserServiceImpl();
        //这里强转是因为setUserDao是子类独有的方法，父类没有
        ((UserServiceImpl) userService1).setUserDao(new UserDaoMysqlImpl());
        userService1.getUser();
    }
}

IOC 本质

控制反转IoC是一种设计思想，DI是实现IOC的一种方法。没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，所谓控制反转就是：获得对象的方式反转了。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

代码：HelloSpring
<!--    使用Spring来创建对象，在Spring中这些都称为Bean-->
<!--    如果我们这个实体类的set方法去掉，会直接报错-->
<!--    所以现在就是如果增加了实现类，其他代码都不变，只需要改这个配置文件就行了，然后-->
<!--    就直接去Spring容器拿对象-->
    <bean id="hello" class="com.lyle.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>

IOC创建对象的方式

1. 无参构造创建对象，默认方式
2. 有参构造：

• 下标赋值
• 通过类型

3. 通过参数名赋值

    <!--    使用Spring来创建对象，在Spring中这些都称为Bean-->
    <!--    如果我们这个实体类的set方法去掉，会直接报错-->
    <!--    所以现在就是如果增加了实现类，其他代码都不变，只需要改这个配置文件就行了，然后-->
    <!--    就直接去Spring容器拿对象-->
<!--    <bean id="user" class="com.lyle.pojo.User">-->
<!--        无参构造-->
<!--        <property name="name" value="Lyle"/>-->
<!--        第一种：下标赋值-->
<!--        <constructor-arg index="0" value="Lyle"/>-->
<!--    </bean>-->

<!--    第二种方式：通过类型创建，不建议使用-->
    <bean id="user" class="com.lyle.pojo.User">
        <constructor-arg type="java.lang.String" value="Lyle"/>
    </bean>

<!--    第三种，直接通过参数名来设置-->
    <bean id="user" class="com.lyle.pojo.User">
        <constructor-arg name="name" value="Lyle"/>
    </bean>
</beans>

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

Spring配置

别名

<alias name="user" alias="userNew"/>
name也是别名，而且name可以同时取多个别名
<bean id="userT" class="com.lyle.pojo.UserT" name="user2,u2">
</bean>

import
这个import，一般用于团队开发使用，他可以将多个配置文件，导入合并为一个
假设，现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以用import将所有人的beans.xml合并为一个总的

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

使用的时候，直接使用总的配置就可以了

依赖注入

构造器注入

前面已经说过了

set方式注入（重点）

代码：Spring-di

拓展方式

p和c命名空间

<!--    p命名空间注入 可以直接注入属性的值：property-->
    <bean id="user" class="com.lyle.pojo.User" p:name="Lyle" p:age="18"/>

<!--    c命名空间注入，通过构造器注入：construct-args-->
    <bean id="user2" class="com.lyle.pojo.User"  c:age="19" c:name="Lyle2"/>

Bean的作用域

singleton, prototype, 其他的request, session, application只能在web开发中使用到。

Bean的自动装配

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

在Spring中有三种装配的方式

1. 在xml中显示的配置
2. 在java中显示配置
3. 隐式的自动装配bean（重要）

测试环境搭建

public class MyTest {
    @Test
    public void test1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        People people = context.getBean("people", People.class);
        people.getDog().shout();
        people.getCat().shout();
    }
}

ByName和ByType自动装配

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

<!--    <bean id="people" class="com.lyle.pojo.People">-->
<!--        <property name="name" value="Lyle"/>-->
<!--        <property name="dog" ref="Dog"/>-->
<!--        <property name="cat" ref="cat"/>-->
<!--    </bean>-->

<!--    byname:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid-->
<!--    byType会自动在容器上下文中查找，和自己对象属性类型相同的bean-->
<!--    <bean id="people" class="com.lyle.pojo.People" autowire="byType">-->
    <bean id="people" class="com.lyle.pojo.People" autowire="byName">
        <property name="name" value="Lyle"/>
    </bean>

使用注解实现自动装配

JDK1.5支持注解，Spring2.5支持注解。
要使用注解须知：

1. 导入约束：context约束
2. 配置注解的支持：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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

<!--    开启注解支持-->
    <context:annotation-config/>
</beans>

@Autowired
直接在属性上使用即可！也可以在set方法上使用。
使用@Autowired 我们可以不写set方法了，前提是这个自动装配属性在IOC容器中存在，且符合名字byName.
科普：
@Nullable 字段标注了这个注解，说明这个字段可以为null
如果显式定义了Autowired 的required属性为false，说明这个对象可以为null，否则不允许为空

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

@Resource注解

public class People {
  @Resource(name = "cat2")
  private Cat cat;

  @Resource
  private Dog dog;
}

@Resource和@Autowired的区别：

• 都是用来自动装配的，都可以放在属性字段上
• @Autowired 通过byName的方式实现
• @Resource 默认通过byName的方式实现，如果找不到名字，则通过byType实现。如果两个都找不到的情况下，就报错。
• 执行顺序不同：@Autowired通过byType的方式实现 @Resource默认通过byName的方式实现

使用注解开发

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

属性如何注入

@Component
public class User {
//    public String name = "Lyle";
    @Value("Lyle")
    public String name;
    
    @Value("Lyle")
    public void setName(String name) {
        this.name = name;
    }
}

@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层

小结：

• xml更加万能，维护简单方便
• xml用来管理bean
• 注解只负责属性的注入

静态代理

代理模式的好处：

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

缺点：

• 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低

动态代理

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的
• 动态代理分为两类：基于接口的动态代理和基于类的动态代理
  • 基于接口 -- JDK动态代理
  • 基于类： cglib
  • Java字节码

AOP

AOP意为：面向切面编程
AOP其实就是为了代码复用并降低模块之间的耦合，代码也更好维护，也能集中管理非业务代码。

Spring的构造型注解

来自Spring实战5一书，提到 @Repository， @Controller，@Component都是构造型注解，应该是指这些注解标记的类会被Spring接管并初始化为容器（Spring上下文）中的bean，