Spring学习日记

Spring

Spring : 春天 —>给软件行业带来了春天

2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。

2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。

很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。

Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术

官网 : http://spring.io/

官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/

GitHub : https://github.com/spring-projects

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

1.优点

1、Spring是一个开源免费的框架 , 容器 .

2、Spring是一个轻量级的框架 , 非侵入式的 .

3、控制反转 IoC , 面向切面 Aop

4、对事物的支持 , 对框架的支持

…

一句话概括：

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

2.组成

3.Spring设计理念
Spring的设计理念可以概括为以下几点：

1.轻量级：Spring框架采用了轻量级的设计方式，尽可能减少对系统资源的占用，使得应用程序可以快速启动并运行。它只需要很少的配置信息，而且对于开发者来说也非常简单易用。

2.松耦合：Spring通过依赖注入（DI）和面向接口编程的方式，实现了组件之间的松耦合。应用程序的不同模块可以独立开发、测试和维护，降低了系统的复杂性，并提高了代码的可重用性和可扩展性。

3.面向切面编程（AOP）：Spring框架支持AOP编程，可以将一些与业务逻辑无关的横切关注点（如日志记录、事务管理等）从应用程序的主要业务逻辑中解耦出来，通过配置的方式，将这些关注点以切面的方式插入到应用程序的执行流程中。

4.容器化：Spring框架提供了一个IoC容器，即控制反转容器，负责创建和管理对象的生命周期。通过IoC容器，可以将应用程序的对象的创建和依赖关系的管理交给Spring框架来完成，大大简化了开发工作，并提高了代码的可测试性和可维护性。

5.综合性：Spring框架提供了众多的功能模块，涵盖了从应用程序的基础设施层（如数据访问、事务管理、安全性等）到业务逻辑层的各个方面。开发者可以根据自己的需求选择需要的模块，灵活地构建自己的应用程序。

总体而言，Spring的设计理念是以简单、灵活和可扩展为核心，通过提供一系列的功能模块和设计原则，帮助开发者更加高效地开发企业级应用程序。

4.初识Ioc与DI

我们首先来讲解一下IoC的概念。IoC(控制反转:Inverse of Control)是Spring容器的核心，但是IoC这个概念却比较晦涩，让人不太容易望文生义。

1、IoC控制反转和DI依赖注入

　　传统程序设计中，我们需要使用某个对象的方法，需要先通过new创建一个该对象，我们这时是主动行为；而IoC是我们将创建对象的控制权交给IoC容器，这时是由容器帮忙创建及注入依赖对象，我们的程序被动的接受IoC容器创建的对象，控制权反转，所以叫控制反转。

　　由于IoC确实不够开门见山，所以提出了DI（依赖注入：Dependency Injection）的概念，即让第三方来实现注入，以移除我们类与需要使用的类之间的依赖关系。总的来说，IoC是目的，DI是手段，创建对象的过程往往意味着依赖的注入。我们为了实现IoC，让生成对象的方式由传统方式(new)反转过来，需要创建相关对象时由IoC容器帮我们注入(DI)。

　　简单的说，就是我们类里需要另一个类，只需要让Spring帮我们创建 ，这叫做控制反转；然后Spring帮我们将需要的对象设置到我们的类中，这叫做依赖注入。

5、常见的几种注入方法

• 使用有参构造方法注入

public class  User{
    private String name;
    public User(String name){
        this.name=name;
    }
} 

    User user=new User("tom");

• 使用属性注入

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

     User user=new User();
     user.setName("jack");

• 使用接口注入

// 将调用类所有依赖注入的方法抽取到接口中，调用类通过实现该接口提供相应的注入方法。 

public interface Dao{
    public void delete(String name);
} 

public class DapIml implements Dao{
    private String name;
    public void delete(String name){
        this.name=name;
    }
}

通过容器完成依赖关系的注入

上面的注入方式都需要我们手动的进行注入，如果有一个第三方容器能帮助我们完成类的实例化，以及依赖关系的装配，那么我们只需要专注于业务逻辑的开发即可。Spring就是这样的容器，它通过配置文件或注解描述类和类之间的依赖关系，自动完成类的初始化和依赖注入的工作。

3、Spring的IoC例子

(1) 创建工程，导入jar包

这里我们只是做IoC的操作，所以只需要导入核心模块里的jar包，beans、core、context、expression等。因为spring中并没有日志相关的jar包，所以我们还需要导入log4j和commons-logging。

(2) 创建一个类

public class User {
    public void add(){
        System.out.println("add.....");
    }
}

(3) 创建一个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="user" class="com.cad.domain.User"/>        
</beans>

(4) 进行测试

//这只是用来测试的代码，后期不会这么写
public class Test {

    @org.junit.Test
    public void test(){
        //加载配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
        //获取对象
        User user=(User) context.getBean("user");
        System.out.println(user);
        //调用方法
        user.add();
    }
}

在容器启动时，Spring会根据配置文件的描述信息，自动实例化Bean并完成依赖关系的装配，从容器中即可获得Bean实例，就可以直接使用。Spring为什么仅凭一个简单的配置文件，就能神奇的实例化并配置好程序使用的Bean呢？答案是通过 Java的反射技术。

4、Spring的DI例子

我们的service层总是用到dao层，以前我们总是在Service层new出dao对象，现在我们使用依赖注入的方式向Service层注入dao层。

// UserDao
public class UserDao {
    public void add(){
        System.out.println("dao.....");
    }
}

// UserService
public class UserService {
    UserDao userdao;
    public void setUserdao(UserDao userdao){
        this.userdao=userdao;
    }

    public void add(){
        System.out.println("service.......");
        userdao.add();
    }
}

-------------------------------分割线--------------------------

// 配置文件
<bean id="userdao" class="com.cad.domain.UserDao"></bean> 
//这样在实例化service的时候，同时装配了dao对象，实现了依赖注入
<bean id="userservice" class="com.cad.domain.UserService">
    //ref为dao的id值
    <property name="userdao" ref="userdao"></property>
</bean>

6、Spring资源访问神器——Resource接口

JDK提供的访问资源的类(如java.NET.URL,File)等并不能很好很方便的满足各种底层资源的访问需求。Spring设计了一个Resource接口，为应用提供了更强的访问底层资源的能力，该接口拥有对应不同资源类型的实现类。

1、Resource接口的主要方法

• boolean exists()：资源是否存在
• boolean isOpen()：资源是否打开
• URL getURL()：返回对应资源的URL
• File getFile()：返回对应的文件对象
• InputStream getInputStream()：返回对应资源的输入流

Resource在Spring框架中起着不可或缺的作用，Spring框架使用Resource装载各种资源，包括配置文件资源，国际化属性资源等。

2、Resource接口的具体实现类

• ByteArrayResource：二进制数组表示的资源
• ClassPathResource：类路径下的资源 ，资源以相对于类路径的方式表示
• FileSystemResource：文件系统资源，资源以文件系统路径方式表示，如d:/a/b.txt
• InputStreamResource：对应一个InputStream的资源
• ServletContextResource：为访问容器上下文中的资源而设计的类。负责以相对于web应用根目录的路径加载资源
• UrlResource：封装了java.net.URL。用户能够访问任何可以通过URL表示的资源，如Http资源，Ftp资源等

3、Spring的资源加载机制

为了访问不同类型的资源，必须使用相应的Resource实现类，这是比较麻烦的。Spring提供了一个强大的加载资源的机制，仅通过资源地址的特殊标识就可以加载相应的资源。首先，我们了解一下Spring支持哪些资源类型的地址前缀:

• classpath：例如classpath:com/cad/domain/bean.xml。从类路径中加载资源
• file：例如 file:com/cad/domain/bean.xml.使用UrlResource从文件系统目录中加载资源。
• http：// 例如http://www.baidu.com/resource/bean.xml 使用UrlResource从web服务器加载资源
• ftp：// 例如frp://10.22.10.11/bean.xml 使用UrlResource从ftp服务器加载资源

Spring定义了一套资源加载的接口。ResourceLoader接口仅有一个getResource(String location)的方法，可以根据资源地址加载文件资源。资源地址仅支持带资源类型前缀的地址，不支持Ant风格的资源路径表达式。ResourcePatternResolver扩展ResourceLoader接口，定义新的接口方法getResources(String locationPattern)，该方法支持带资源类型前缀以及Ant风格的资源路径的表达式。PathMatchingResourcePatternResolver是Spring提供的标准实现类。

4、例子

public class Test {
    public static void main(String[] args) throws IOException {
        ResourceLoader resloLoader = new DefaultResourceLoader();
        Resource res = resloLoader.getResource("https://www.baidu.com/");
        System.out.println(res instanceof UrlResource); // true
        BufferedReader bf = new BufferedReader(new InputStreamReader(res.getInputStream()));
        StringBuilder sb = new StringBuilder();
        String temp = null;
        while ((temp = bf.readLine())!= null) {
            sb.append(temp);
        }
        System.out.println(sb.toString());

        System.out.println("\n-----------------------------\n");
        res = resloLoader.getResource("classpath:test.txt");
        bf = new BufferedReader(new InputStreamReader(res.getInputStream()));
        sb = new StringBuilder();
        temp = null;
        while ((temp = bf.readLine())!= null) {
            sb.append(temp);
        }
        System.out.println(sb.toString());

        System.out.println("\n-----------------------------\n");
        res = resloLoader.getResource("file:C:\\Users\\ricco\\Desktop\\test\\test.txt");
        bf = new BufferedReader(new InputStreamReader(res.getInputStream()));
        sb = new StringBuilder();
        temp = null;
        while ((temp = bf.readLine())!= null) {
            sb.append(temp);
        }
        System.out.println(sb.toString());
    }
}