带你了解Spring~

傷城~ 2024-03-26 17:15 121阅读 0赞

文章目录

第一章：Spring框架的介绍

第二章：创建Hello world

第三章：Spring IOC容器

第四章：Spring框架的Bean管理

--------------------

#### 第一章：Spring框架的介绍 ####

**1. Spring框架的概述**

Spring是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。

Spring是于2003 年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。

它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 JavaEE 应用程序开发提供集成的框架。

Spring的核心是控制反转（IOC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

>  IOC:控制反转，将创建对象的过程交给spring进行管理
> 
>  AOP:面向切面，在不修改源代码的情况之下进行代码功能的增强

**2. Spring框架的优点**

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

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

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

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

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

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

#### 第二章：创建Hello world ####

创建maven工程，导入坐标依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

编写demo，编写具体的实现方法

public class Demo {
        public void hello() {
            System.out.println("hello world");
        }
    }

编写Spring核心的配置文件，在resources目录下创建applicationContext.xml的配置文件，名称是可以任意的，但是一般都会使用默认名称。

![bb795111e23e4c3b8c0c5bf5a79b682b.png][]

<?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="demo" class="com.test.service.Demo" />
    </beans>

编写测试方法。

import com.qcby.service.UserService;
    import com.qcby.service.UserServiceImpl;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class UserServiceTest {
        //传统写法
        @Test
        public void run(){
            Demo userService = new Demo();
            userService.hello();
        }
        //spring写法
        @Test
        public void run1(){
        	//创建spring工厂，加载配置文件
        	ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        	//获取bean对象
        	Demo us = (Demo) ac.getBean("us");
        	//调用方法
        	us.hello();
        }
    
    }

#### 第三章：Spring IOC容器 ####

**1. 什么是IOC**

IOC -- Inverse of Control，控制反转，将对象的创建权力反转给Spring框架！

> 在java当中一个类想要使用另一个类的方法，就必须在这个类当中创建这个类的对象，那么可能会出现如下情况： 比如A类当中创建着B对象，B类当中有C对象，C类当中有A对象，这个如果一个类出了问题，那么可能会导致这个框架出现问题。 Spring 将创建对象的权利给了IOC，在IOC当中创建了ABC三个对象吗，那么我们我们其他的类只需要调用集合， 大大的解决了程序耦合性的问题。

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。

解决问题：使用IOC可以解决程序耦合性高的问题。

**2. IOC容器的底层原理**

IOC的实现，依赖于以下3门技术

① dom4j解析xml文档；

② 工厂模式；

③ 采用反射设计模式创建对象

**首先我们需要讲一下什么是工厂模式**

![b545497eb8014e2ab1609117ee7b7f05.png][]

在当前情况之下A类想要调用B类就必须自己在自己的内部新建B类的对象，这样的耦合度太高，那我们如何降低耦合度的呢？

![52e0693162d64d7cb70ec1cff118bb9c.png][]

创建一个工厂类，这样就能够使得A和B的耦合度降低到最小值

那么上边提到的三种技术如何实现IOC的呢？

**第一步：xml配置文件，配置创建对象**

**第二步：创建工厂类**

public class DemoFactory {
        //利用dom4j得到name所对应的value值
       public static Demo getDemo() throws Exception {
           //利用dom4j得到name所对应的value值
           String value="class路径";
           //通过反射创建对象
           Class clazz = Class.forName(value);
           //返回并创建demo对象
           return (Demo) clazz.newInstance();
       }
    }

通过以上两步，我们基本上就可以得到我们所创建的对象。

**3.IOC(接口)**

1.IOC思想是基于IOC容器完成的，IOC的底层就是对象工厂

2.Spring里边提供了IOC容器的实现的两种方式

(1) BeanFactroy：IOC容器是Spring内部的使用接口，不提供给开发人员使用

![a9ed1f37be774969976978a31af7120c.png][]

\* BeanFactroy:加载配置文件的时候不会去创建对象，在使用对象的时候才会去创建对象

(2)ApplicationContext:BeanFactory接口的子接口，提供了更多更强大的功能，一般由开发人员进行使用

![a1eada6b438e485b9e85669f0dce2627.png][]

\*加载配置文件的时候会把对象创建

#### **第四章：Spring框架的Bean管理** ####

**(1).什么是Bean个管理**

> bean管理指的是如下的两个操作。
> 
> 1.创建对象 2.注入属性

**(2).Bean管理操作的两种方式**

> 1.基于xml配置文件的方式实现
> 
> 2.基于注解方式实现

(3).基于xml配置文件的方式实现Bean管理和注入属性

**1.基于xml方式创建对象**

> ①：这个就是我们上边配置过
> 
> ②：创建对象的时候，默认是执行无参构造方法完成对象

#### 2.基于xml方式注入属性 ####

*  **依赖注入的概述**

IOC和DI的概念

IOC：Inverse of Control，控制反转，将对象的创建权反转给Spring！！

DI：Dependency Injection，依赖注入，就是注入属性

*  **属性的set方法注入值**

编写属性，提供该属性对应的set方法，编写配置文件完成属性值的注入

public class User {
        // 编写成员属性，一定需要提供该属性的set方法
        //IOC容器底层就通过属性的set方法方式注入值
        private int age;
        private String name;
        private Demo demo;
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void setDemo(Demo demo) {
            this.demo = demo;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    ", demo=" + demo +
                    '}';
        }
    }

<!‐‐DI：依赖注入‐‐>
    <bean id="user" class="com.qcby.service.User" >
        
        <property name="age" value="18"></property>
        <property name="name" value="张三"></property>
        <property name="demo" ref="demo"></property>
    </bean>
    
    <bean id="demo" class="com.test.service.Demo" />

@Test
    public void run1(){
        //创建spring工厂，加载配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        //获取bean对象
        User user = ac.getBean("user", User.class);
    
        System.out.println(user.toString());
    
    }

*  **属性构造方法方式注入值**

对于类成员变量，构造函数注入。

public class Car {
        // 名称
        private String cname;
        // 金额
        private Double money;
    
        public Car(String cname,Double money){
            this.cname = cname;
            this.money = money;
        }
    
        @Override
        public String toString() {
            return "Car{" +
                    "cname='" + cname + '\'' +
                    ", money=" + money +
                    '}';
        }
    }

@Test
    public void run(){
        //创建spring工厂，加载配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        //获取bean对象
        Car car = ac.getBean("car", Car.class);
        System.out.println(car.toString());
    }

*  **数组，集合(List,Set,Map)等的注入**
    
        public class CollectionBean {
        
            private String [] strs;
            private List<String> list;
            private Map<String,String> map;
        
            public void setStrs(String[] strs) {
                this.strs = strs;
            }
        
            public void setList(List<String> list) {
                this.list = list;
            }
        
            public void setMap(Map<String, String> map) {
                this.map = map;
            }
        
            @Override
            public String toString() {
                return "CollectionBean{" +
                        "strs=" + Arrays.toString(strs) +
                        ", list=" + list +
                        ", map=" + map +
                        '}';
            }
        }

<!‐‐给集合属性注入值‐‐>
    <bean id="collectionBean" class="com.qcby.service.CollectionBean">
        <property name="strs">
            <array>
                <value>美美</value>
                <value>小凤</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>熊大</value>
                <value>熊二</value>
            </list>
        </property>
        <property name="map">
            <map>
                <entry key="aaa" value="老王"/>
                <entry key="bbb" value="小王"/>
            </map>
        </property>
    </bean>

@Test
    public void getValue(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Demo demo = (Demo) applicationContext.getBean("demo");
        System.out.println(demo.toString());
    }

#### **(4).基于注解的方式实现Bean管理和注入属性** ####

**1.什么是注解**

①：注解是代码特殊标记，格式：@注解名称(属性名称=属性值，属性名称=属性值...)

②：使用注解，注解作用在类上面，方法上面，属性上边

③：使用注解的目的：简化XML配置

**2.Spring针对Bean管理中创建对象提供的注解**

@Component 普通的类

@Controller 表现层

@Service 业务层

@Repository 持久层

\*上边四个功能一样，都可以用来创建bean实例

**3.用注解的方式创建对象**

①：编写接口和实现类

package com.test.testanno;
    
    public interface UserService {
        public void hello();
    }

②：在需要管理的类上添加@Component注解

import org.springframework.stereotype.Component;
    
    /* <bean id="us" class="UserServiceImpl"/> */
    /**
     * 组件，作用：把当前类使用IOC容器进行管理，如果没有指定名称，默认使用类名，首字母是小写。
     * userServiceImpl。或者自己指定名称
     **/
    @Controller(value="us")
    public class UserServiceImpl implements UserService {
        public void hello() {
            System.out.println("使用注解，方便吧！");
        }
    }

③：编写配置文件，重点是开启注解扫描。

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

写测试方法

import com.test.testanno.UserService;
    import org.junit.Test;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Demo2 {
        @Test
        public void run1(){
            ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContextanno.xml");
            UserService us = (UserService) ac.getBean("us");
            us.hello();
        }
    }

#### 4.用注解的方实现属性注入 ####

@Value 用于注入普通类型（String，int，double等类型）

@Autowired 默认按类型进行自动装配（引用类型）

@Qualifier 不能单独使用必须和@Autowired一起使用，强制使用名称注入

@Resource Java提供的注解，也被支持。使用name属性，按名称注入

具体的代码如下：

// 默认当前类名就是ID名称，首字母小写
    @Component(value = "c")
    // @Controller
    // @Service(value = "c")
    // @Repository(valu = "c")
    public class Car {
        // 注解注入值，属性set方法是可以省略不写的。
        // 只有一个属性，属性的名称是value，value是可以省略不写的
        @Value("大奔2")
        private String cname;
        @Value(value = "400000")
        private Double money;
        // 也不用提供set方法
        // 按类型自动装配的注解，和id名称没有关系
    
        @Autowired
        // 按id的名称注入，Qualifier不能单独使用，需要Autowired一起使用。
        // @Qualifier(value = "person")
        // @Resource Java提供的注解，按名称注入对象，属性名称是name
        // @Resource(name = "person")
        private Person person;
    
    
        @Override
        public String toString() {
            return "Car{" +
                    "cname='" + cname + '\'' +
                    ", money=" + money +
                    ", person=" + person +
                    '}';
        }
    
    }

@Controller
    //@Component(value = "person")
    public class Person {
    
        @Value("张三")
        private String pname;
        @Override
        public String toString() {
            return "Person{" +
                    "pname='" + pname + '\'' +
                    '}';
        }
    
    }

@Test
    public void run1(){
        // 工厂
        ApplicationContext ac = new
                ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取对象
        Car car = (Car) ac.getBean("c");
        System.out.println(car);
    }

**(5). IOC纯注解的方式**

纯注解的方式是微服务架构开发的主要方式，所以也是非常的重要。纯注解的目的是替换掉所有的配置文件。但是需要编写配置类。

常用的注解总结

@Configuration 声明是配置类

@ComponentScan 扫描具体包结构的

编写实体类

@Component
    public class Order {
        @Value("北京")
        private String address;
        @Override
        public String toString() {
            return "Order{" +
                    "address='" + address + '\'' +
                    '}';
        }
    }

编写配置类，替换掉applicationContext.xml配置文件

@Configuration
    // 扫描指定的包结构
    @ComponentScan(value = "com.qcby")
    public class SpringConfig {
    }

测试方法的编写

public class Demo4 {
        @Test
        public void run(){
            // 创建工厂，加载配置类
            ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfig.class);
            // 获取到对象
            Order order = (Order) ac.getBean("order");
            System.out.println(order);
        }
    }

--------------------

![24c5f0074f874910ab02c763019e5059.jpeg][]

[bb795111e23e4c3b8c0c5bf5a79b682b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/86b07ca92ef04279a954c2e52dd1df40.png
[b545497eb8014e2ab1609117ee7b7f05.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/7ff3714a5a1f4a6cb33d27a52a8d6c8c.png
[52e0693162d64d7cb70ec1cff118bb9c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/bccfea2aaaf84fdcab05235dea6762c1.png
[a9ed1f37be774969976978a31af7120c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/4e4b169ea31e480989357da41ca4d100.png
[a1eada6b438e485b9e85669f0dce2627.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/b345466d673f4f52bdca54d7b299be1f.png
[24c5f0074f874910ab02c763019e5059.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/9023ae538292434999eb5041b644dde9.png