spring框架

1.介绍spring框架

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

2.spring 系统架构

3.spring的特点

Spring 框架具有以下几个特点。

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

方便集成各种优秀框架
Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如 Struts2、Hibernate、MyBatis 等）的直接支持。

降低 Java EE API 的使用难度
Spring 对 Java EE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等）都提供了封装，使这些 API 应用的难度大大降低。

方便程序的测试
Spring 支持 JUnit4，可以通过注解方便地测试 Spring 程序。

AOP 编程的支持
Spring 提供面向切面编程，可以方便地实现对程序进行权限拦截和运行监控等功能。

声明式事务的支持
只需要通过配置就可以完成对事务的管理，而无须手动编程。

3.1程序的耦合

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

它有如下分类：

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

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

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

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

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

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

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

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

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

4.控制反转IOC

在传统的 Java 应用中，一个类想要调用另一个类中的属性或方法，通常会先在其代码中通过 new Object() 的方式将后者的对象创建出来，然后才能实现属性或方法的调用。为了方便理解和描述，我们可以将前者称为“调用者”，将后者称为“被调用者”。也就是说，调用者掌握着被调用者对象创建的控制权。

但在 Spring 应用中，Java 对象创建的控制权是掌握在 IoC 容器手里的，其大致步骤如下。
开发人员通过 XML 配置文件、注解、Java 配置类等方式，对 Java 对象进行定义，例如在 XML 配置文件中使用 标签、在 Java 类上使用 @Component 注解等。
Spring 启动时，IoC 容器会自动根据对象定义，将这些对象创建并管理起来。这些被 IoC 容器创建并管理的对象被称为 Spring Bean。
当我们想要使用某个 Bean 时，可以直接从 IoC 容器中获取（例如通过 ApplicationContext 的 getBean() 方法），而不需要手动通过代码（例如 new Obejct() 的方式）创建。

IoC 带来的最大改变不是代码层面的，而是从思想层面上发生了“主从换位”的改变。原本调用者是主动的一方，它想要使用什么资源就会主动出击，自己创建；但在 Spring 应用中，IoC 容器掌握着主动权，调用者则变成了被动的一方，被动的等待 IoC 容器创建它所需要的对象（Bean）。

这个过程在职责层面发生了控制权的反转，把原本调用者通过代码实现的对象的创建，反转给 IoC 容器来帮忙实现，因此我们将这个过程称为 Spring 的“控制反转”。

5.如何使用spring

1.引入依赖

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

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"
       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">
       

<!--        表示一个类交给spring容器来创建 id：bean的唯一标识 class 类的全路径-->
        <bean id="userDao01" class="com.lzl.demo01.UserDao02" />
        
</beans>

3.创建一个Dao类

package com.lzl.demo02;

/**
 * @create 2022-06-14
 */
public interface UserDao {
    public void show();
}

package com.lzl.demo02;

import org.springframework.stereotype.Repository;

/**
 * @create 2022-06-14
 */

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

4.测试

public class Test01 {
    public static void main(String[] args) {
        //读取spring配置文件
        ApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");
        //获取bean对象 多态.
        UserDao userdao = (UserDao) app.getBean("userDao01");
        userDao.show();
    }
}

6. BeanFactory和ApplicationContext的区别

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：基于注解的配置。基于类书写的配置。

BeanFactory和ApplicationContext区别:

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

选择:饿汉式:

7. 获取bean的方式

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

//根据bean 的id获取 需要强转型
UserDao userdao = (UserDao) app.getBean("userDao01");

2. 通过类型获取

//类型唯一 要不会报错
UserDao userdao =  app.getBean(UserDao.class);

3. 通过id 加类名获取

UserDao userdao =  app.getBean("userDao01",UserDao.class);

8. bean的作用范围

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

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

scope：常用 singleton,prototype

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

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

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

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

9.依赖注入 DI

DI 依赖注入：目的就是给对象中的属性赋值。

10.如何实现注入对象的属性值

(1)创建一个类:—提供set方法

package com.lzl.entity;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @create 2022-06-13
 */
public class Student {
    private  String name;
    private Integer age;
    private Clazz clazz;
    private List hobby;
    private Integer[] sex;
    private Set set;
    private Map map;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", clazz=" + clazz +
                ", hobby=" + hobby +
                ", sex=" + Arrays.toString(sex) +
                ", set=" + set +
                ", map=" + map +
                '}';
    }

    public Set getSet() {
        return set;
    }

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

    public Map getMap() {
        return map;
    }

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

    public Integer[] getSex() {
        return sex;
    }

    public void setSex(Integer[] sex) {
        this.sex = sex;
    }

    public List getHobby() {
        return hobby;
    }

    public void setHobby(List hobby) {
        this.hobby = hobby;
    }

    public Clazz getClazz() {
        return clazz;
    }

    public void setClazz(Clazz clazz) {
        this.clazz = clazz;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

}

(2)配置文件:—在bean标签中

 <bean id="Student" class="com.lzl.entity.Student">
        <property name="name" value="张三"></property>
        <property name="age" value="15" />
        <property name="clazz" ref="clazz01"/>
        <property name="hobby">
            <list>
                <value>吃饭</value>
                <value>睡觉</value>
                <value>打豆豆</value>
            </list>

        </property>
        <property name="sex">
            <array>
                <value>0</value>
                <value>2</value>
                <value>1</value>
            </array>
        </property>
        <property name="set" >
            <set>
                <value>张三</value>
                <value>张三</value>
                <value>李四</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="name" value="张san"/>
                <entry key="age" value="18" />
                <entry key="address" value="郑州" />
            </map>
        </property>
       </bean>
    <bean id="clazz01" class="com.lzl.entity.Clazz">
        <property name="cid" value="1" />
        <property name="cname" value="151" />
     </bean>

11. 自动注入。

package com.lzl.demo01;

/**
 * @create 2022-06-14
 */
public class UserController {
    private UserDao userDao01;

    public void setUserDao01(UserDao userDao01) {
        this.userDao01 = userDao01;
    }
    public void print(){
        userDao01.show();
    }
}


package com.lzl.demo02;

/**
 * @create 2022-06-14
 */
public interface UserDao {
    public void show();
}


package com.lzl.demo01;

/**
 * @create 2022-06-14
 */
public class UserDao01 implements UserDao{
    public void show() {
        System.out.println("111111111111111111111");
    }
}


package com.lzl.demo01;

/**
 * @create 2022-06-14
 */
public class UserController {
    private UserDao userDao01;

    public void setUserDao01(UserDao userDao01) {
        this.userDao01 = userDao01;
    }
    public void print(){
        userDao01.show();
    }
}

2.bean配置文件

<?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">
        <bean id="userController" class="com.lzl.demo01.UserController" autowire="byName"></bean>
        <bean id="userDao01" class="com.lzl.demo01.UserDao02" />
       
</beans>

3.测试

package com.lzl.demo01;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @create 2022-06-14
 */
public class Test01 {
    public static void main(String[] args) {
        ApplicationContext app = new  ClassPathXmlApplicationContext("spring.xml");
        UserController userController = (UserController) app.getBean("userController");
        userController.print();
    }
}

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

（1）包扫描配置文件

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

（2）创建controller

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;

/**
 * @create 2022-06-14
 */
@Controller
public class UserController {
    @Autowired //按照类型自动注入
//    @Qualifier(value = "userDao02")
    private UserDao userDao01;

    public void setUserDao01(UserDao userDao01) {
        this.userDao01 = userDao01;
    }
    public void print(){
        userDao01.show();
    }
}

(3) dao接口和实现类

package com.lzl.demo02;

import org.springframework.stereotype.Repository;

/**
 * @create 2022-06-14
 */
@Repository
public class UserDao01 implements UserDao {
    public void show() {
        System.out.println("111111111111111111111");
    }
}

package com.lzl.demo02;

import org.springframework.stereotype.Repository;

/**
 * @create 2022-06-14
 */
@Repository
public class UserDao02 implements UserDao {
    public void show() {
        System.out.println("2222222222222222222222222222");
    }
}

13.分层

注释

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