Spring

原创已于 2022-06-19 21:07:27 修改 · 101 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#spring #java #后端

于 2022-06-19 20:48:24 首次发布

1.简介

1. spring是一个轻量级开源的JAVAEE框架。
2. Spring提高了IOC和AOP
IOC:控制反转。把创建java对象的权力交于spring容器来管理。
AOP:面向切面编程.在不改变源代码的前提下可以扩充功能。
3. spring的特点:
方便解耦，简化开发----层层之间的依赖降低。
声明式事务的支持：
方便程序的测试：----提供单元测试jar，
方便集成各种优秀框架---集成第三方的框架---mybatis

4.目的：

降低耦合：对象与对象之间的耦合

2.程序的耦合

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。

它有如下分类：

（1）内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。

（2）公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。

（3）外部耦合。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。

（4）控制耦合。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。

（5）标记耦合。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间存在一个标记耦合。

（6）数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。

（7）非直接耦合。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。

总结：耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。

内聚与耦合：内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。

3. 解决办法IOC控制反转

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

==使用对象的时候不再是我们直接new，而是将创建对象的权利交给框架中的核心容器IOC，需要使用对象的时候直接从容器中获取。==

IoC的思想早就出现了，但是没有一个具体的实现，大家都是各自根据这个思想去写代码(自己去创建工厂)。后来有一个大师 Rod Johnson（Spring Framework创始人，著名作者。 Rod在悉尼大学不仅获得了计算机学位，同时还获得了音乐学位。更令人吃惊的是在回到软件开发领域之前，他还获得了音乐学的博士学位。），写了一个框架，将IoC思想具体的实现了，这个框架后来起了个名字叫做 Spring。（因为在这之前大家都是用hibernate这个框架，这个框架中文名字叫做冬眠，并且这个框架比较笨重，耦合比较高。Rod Johnson写的框架就是用来解决类似于hibernate高耦合的问题，所以他将自己框架的名字命名为 Spring 告诉全世界冬天过去了春天来了）。

4.使用

1.加载依赖

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

2.配置文件

<?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容器来创建
          id:bean的唯一标识。
          class: 类的全路径
    -->

    <bean id="prototypebean1" class="com.sal.scope.PrototypeBean" scope="prototype"/>

    <bean id="prototypebean2" class="com.sal.scope.PrototypeBean02" scope="singleton"/>

</beans>

3.Dao类

public class PrototypeBean {
    public PrototypeBean(){
        System.out.println("1.1:初始化");
    }
}

4.测试

    @Test
    public void test01(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        PrototypeBean prototypeBean1 = (PrototypeBean) context.getBean("prototypebean1");
        PrototypeBean prototypeBean2 = (PrototypeBean) context.getBean("prototypebean1");
        System.out.println("1.1:"+prototypeBean1);
        System.out.println("1.2:"+prototypeBean2);
    }

5.BeanFactory和ApplicationContext

1.简介

Spring容器顶层接口：获取Bean对象;

管理类和类之间的关系(依赖关系)BeanFactory由org.springframework.beans.factory.BeanFactory接口定义 BeanFactory是工厂模式（Factory pattern）的实现，是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

BeanFactory接口包含以下基本方法：

containsBean(String beanName) 判断工厂中是否包含给定名称的bean定义，若有则返回true。

Object  getBean(String  str) 返回给定名称注册的bean实例。根据bean的配置情况，如果是singleton模式将返回一个共享实例，否则将返回一个新建的实例，如果没有找到指定bean,该方法可能会抛出异常。

Object  getBean(String, Class) 返回以给定名称注册的bean实例，并转换为给定class类型

Class  getType(String name) 返回给定名称的bean的Class,如果没有找到指定的bean实例，则排除NoSuchBeanDefinitionException异常

boolean  isSingleton(String) 判断给定名称的bean定义是否为单例模式      

String[]  getAliases(String name) 返回给定bean名称的所有别名

ApplicationContext接口

是基于BeanFactory之上的，提供了应用程序框架服务，扩展的新功能如下：提供国际化的支持资源访问，如URL和文件事件传递载入多个配置文件等实现类常见有三个

ClassPathXmlApplicationContext：-classpath路径加载xml文件的

FileSystemXmlApplicationContext：基于项目根路径进行加载xml文件的

AnnotationConfigApplicationContext：基于注解的配置。基于类书写的配置。

public class test01{
        public static void main(String[] args) {
        //读取配置文件
        ClassPathResource resource = new ClassPathResource("applicationContext.xml");
        //解析配置文件
        XmlBeanFactory factory = new XmlBeanFactory(resource);
        //拿到哪个bean时才会调用构造函数创建该bean.
        Object userDao = factory.getBean("userDao"); 

        //当使用到bean对象时，spring才会帮你创建.
        Object people = factory.getBean("people");
    }
}

public static void main(String[] args) {
        //在加载spring容器时，spring会把配置文件中所有的bean创建好。
        ApplicationContext app=new ClassPathXmlApplicationContext("application.xml");
    }

2.BeanFactory和ApplicationContext区别:

BeanFactory 才是 Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
单例模式下创建对象的时间点不一样：
ApplicationContext：(饿汉模式)只要一读取配置文件，马上就会创建配置文件中配置的对象。
BeanFactory：(懒汉模式)什么时候getBean("id")，也就是说当根据id获取对象时，才会创建。

6.获取bean的方式

1.通过bean.xml文件中bean标签的id的值获取bean(使用默认构造方法)

//根据bean的id获取Bean对象，强制转换.
IUserDao iUserDao= (IUserDao) app.getBean("userDao");

2.通过类型去获取

//通过类型获取bean对象。
//确保bean的类型是唯一的 不然会报错
IUserDao userDao = app.getBean(IUserDao.class);

3.通过 id + 类型去获取

IUserDao userDao = app.getBean("userDao2", IUserDao.class);

7.bean的作用范围

bean对象的作用范围调整需要配置scope属性，设置单例还是多例（只针对ApplicationContext接口来说，默认是单例的）

单例:---无论创建多少次对象他们始终指向同一个实例。

scope：常用 singleton,prototype

singleton：单例的（默认值）当加载配置文件时，就会创建对象。

prototype：多例的（当getBean时才会创建对象）

request：作用于请求范围---同一个那么使用bean同一个。

session：作用于会话范围---同一个会话

8.依赖注入DI

1.简介

依赖注入(Dependency Injection)：目的就是给对象中的属性赋值。

IOC控制反转的最终目的就是降低程序的耦合，也就是削减依赖关系。

依赖关系的管理以后都交给spring维护，依赖关系的管理就称之为依赖注入。也就是说在当前类需要用到其它类的对象时，由spring为我们提供，我们只需要在配置文件中说明依赖关系的维护就可以了。

依赖注入的方式：

依赖注入的数据：三种类型

1. 基本数据类型和String

2. 其它bean实体对象类型(在配置文件中或者注解配置过的bean)

3. 复杂类型/集合类型(集合类型只能通过配置文件注入)

方式：

第一种：使用构造函数提供注入

如果使用构造函数注入，需要在bean.xml文件的bean标签中添加constructor-arg标签

标签中的属性：

type : 用于指定要注入的数据的类型，该数据类型也是构造函数中某个或某些参数的类型。

index: 用指定给构造函数中指定索引位置的参数赋值，索引从0开始。

name: 用于给构造函数的参数赋值，指定参数的名称直接赋值（常用）

value : 用于提供基本类型和String类型的数据

ref : 用于指定其它的bean类型数据，它指的就是在spring的IOC核心容器中出现过的bean

注意：在获取bean对象时，必须要注入数据，否则对象无法创建成功。

缺点：改变了bean对象的实例化方式，就算我们在创建对象时，用不到这些数据，也必须提供。

 <!--构造注入-->
    <bean id="p1" class="com.bai.demo2.entity.Person">
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="name" value="张三"></constructor-arg>
        <constructor-arg name="date" ref="d1"></constructor-arg>
    </bean>

    <!--日期对象的bean-->
    <bean id="d1" class="java.util.Date"></bean>

第二种：使用set方法注入(常用)

如果使用set函数注入，需要在bean.xml文件的bean标签中添加 property 标签

需要属性：

name: 用于给无参空构造函数的参数赋值，指定设值的set方法（将set方法的set去掉把大写字母变小写 setAge()====>age）

value : 用于提供基本类型和String类型的数据

ref : 用于指定其它的bean类型数据，它指的就是在spring的IOC核心容器中出现过的bean

优点：解决了构造注入时的问题，可以选择性的注入值，不是必须注入全部了。

 	<!--注入java提供的Date类-->
    <bean id="date" class="java.util.Date"></bean>
    <!--set方法注入-->
    <bean id="person" class="com.aaa.ioc.Person">
        <property name="name" value="李四"></property>
        <property name="age" value="29"></property>
        <property name="birthday" ref="date"></property>
    </bean>

第三种：用注解提供 （注意开启注解的包扫描）

<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="要扫描的包全名"></context:component-scan>
</beans>

注解分类：

1.用于创建对象的：

作用和在xml配置文件中编写一个< bean>标签实现的功能一样

@Component:（只要不属于三层架构 就使用）
	作用：用于把当前类对象存入spring容器中。
	具有value属性，用于指定bean的id，如果不写value，默认跟当前类名对应(首字母改小写)
	@Component("student1")作用就相当于：
	<bean id="id" class="全类名"></bean>
	
衍生三个注解：
@Controller(表现层)     @Service(业务层)      @Repository(持久层)
	这三个注解的作用和@Component注解一样，是spring框架为我们提供的明确的三层架构使用的注解，让我们的三层架构更加清晰。

2.用于注入数据的：

作用和xml文件中bean标签中的property标签的作用一样

@Autowired *****重点
作用：自动按照类型注入，只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功。
    如果IOC容器中没有任何bean的类型和要注入的变量类型匹配，则报错
    如果IOC容器中有多个类型匹配时，会根据要注入的变量名作为id去匹配，如果匹配到了，就可以执行，否则，报错。
注意：使用注解时，set方法就不是必要的了。
以上@Autowired注解存在一定的局限性，(如果核心容器中有多个相同对象，只使用@Autowired是无法注入成功的)如何解决问题？

@Qualifier
	作用：在按照类型注入的基础上再按照名称注入。它再给类成员注入时不能单独使用。但是再给方法注入时可以。
	属性：value 用于指定注入的bean的id

@Resource
	作用：直接按照bean的id注入。它可以独立使用。
	属性：name   用于指定bean的id
以上三个注解都只能注入其它bean类型的数据，而基本类型和String类型无法使用上述注解。那么如何注入基本数据类型和String类型呢？（集合类型只能通过xml注入）

@Value
	作用：用于注入基本数据类型和String数据类型。

9.依赖注入实例

实体类

public class Student {
    private Integer id;
    private String name;
    private Date date;
    private int[] aa;
    private List list;
    private Set set;
    private Map map;

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", date=" + date +
                ", aa=" + Arrays.toString(aa) +
                ", list=" + list +
                ", set=" + set +
                ", map=" + map +
                '}';
    }

    public Map getMap() {
        return map;
    }

    public void setMap(Map map) {
        this.map = map;
    }

    public Student(Integer id, String name, Date date, int[] aa, List list, Set set, Map map) {
        this.id = id;
        this.name = name;
        this.date = date;
        this.aa = aa;
        this.list = list;
        this.set = set;
        this.map = map;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public int[] getAa() {
        return aa;
    }

    public void setAa(int[] aa) {
        this.aa = aa;
    }

    public List getList() {
        return list;
    }

    public void setList(List list) {
        this.list = list;
    }

    public Set getSet() {
        return set;
    }

    public void setSet(Set set) {
        this.set = set;
    }

    public Student() {
    }
}

.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容器来创建
          id:bean的唯一标识。
          class: 类的全路径
    -->
    <bean id="userDao" class="com.aaa.UserDao">

    </bean>
    <bean id="student001" class="com.aaa.entity.Student">
        <property name="id" value="1"/>
        <property name="name" value="张三"/>
        <property name="date" ref="data"/>
        <property name="aa">
            <array>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>asd</value>
                <value>123</value>
                <value>张张</value>
                <value>2020-02-02</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>dsa</value>
                <value>3231</value>
                <value>张</value>
                <value>2022-12-12</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="a" value="a123"/>
                <entry key="b" value="b123"/>
                <entry key="c" value="c123"/>
            </map>
        </property>
    </bean>
    <bean id="data" class="java.util.Date"></bean>
</beans>

接口

public interface IUserDao {
    public void show();
}

重写的接口方法

public class UserDao implements IUserDao{
    public void show() {
        System.out.println("--------");
    }
}

测试：

public class test01 {
    public static void main(String[] args) {
        //读取配置
        ApplicationContext app = new ClassPathXmlApplicationContext("springmvc.xml");
        //获取bean对象
        //IUserDao userDao = (IUserDao) app.getBean("userDao");
        Student sthdent001 = (Student) app.getBean("student001");
        System.out.println(sthdent001);
        //userDao.show();
    }
}

10.自动注入

.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: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 https://www.springframework.org/schema/context/spring-context.xsd">



<!--    <context:component-scan base-package="com.aaa.demo01" />-->
    <bean id="userController" class="com.aaa.demo01.UserController" autowire="byName" >
<!--        <property name="userDao" ref="userDao"/>-->
    </bean>
    <bean id="userDao01" class="com.aaa.demo01.Userdemo001">

    </bean>
    <bean id="userDao" class="com.aaa.demo01.Userdemo002">

    </bean>


</beans>

接口：

public interface UserDao {
    public void show1();
}

重写的接口的方法：

public class Userdemo001 implements UserDao {
    public void show1() {
        System.out.println("001");
    }
}

controller层：

public class UserController {


    private UserDao userDao;


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

    public void fun01(){
        userDao.show1();
    }
}

11.使用注解完成IOC和DI功能

.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: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 https://www.springframework.org/schema/context/spring-context.xsd">


    <context:component-scan base-package="com.aaa.demo02"/>
</beans>

接口：

public interface UserDao {
    public void print();
}

重写的接口方法，利用注解查找

//跟<bean name="com.aa.demo02.UserDemo02">相同 ，id默认是userDemo01(首字母小写)
@Repository
public class UserDemo01 implements UserDao {
    public void print() {
        System.out.println("001");
    }
}

controller层：

//相当于<bean name="com.aaa.demo02.UserController">,默认id是类名(第一个单词字母小写),也可指定@Controller(value="xxx")
@Controller
public class UserController {

    //类似于btType查找
    @Autowired
    //当上面的注解加上下面这个，即是通过tyName查找
    @Qualifier(value = "userDemo02")
    private UserDao userDao;

    public void fun(){
        userDao.print();
    }
}

测试类：

public class test03 {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("bean02.xml");
        UserController userController = (UserController) app.getBean("userController");
        userController.fun();
    }

}

注解：

@Controller+@Respository+@Service+@Component
没有区别: 他们的底层都是用的@Component
实际意思就在于区分层的。
@Controller控制层
@Respository持久化层
@Service 业务层
@Component 最底层的bean注解。

mvc：