Spring（一）程序员的春天

程序员文章站 2024-03-24 08:58:46

...

1. 认识Spring框架

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

2. Spring的重要性

Spring自身提供了七大模块。（基础模块）
1. IOC容器
2. AOP编程
Spring提供了其他的模块
1. SpringSecurity 安全管理框架
2. SpringTask 任务调度
Spring可以帮助简化其他框架Api的使用，这个叫做Spring整合其他框架
1. Spring整合Struts2
2. Spring整合SpringMVC *
3. Spring整合Hibernate
4. Spring整合MyBatis *
5. Spring整合ApacheShiro *
6. Spring整合Redis *
7. Spring整合Jpa *（Java Persist Api）
8. Spring Data Jpa 整合Redis *
9. Spring整合CXF *
10. Spring整合ApacheActiveMQ *
11. Spring整合ElaststicSearch (分布式搜索) *

3. 解耦的好处

解耦：便于后期维护扩展。

构建项目：
高内聚，低耦合。
高内聚：设计时候类内部的关系越紧密越好，一个类只描述一件事。（单一职责原则）
低耦合：类与类的关系越少越好。

4. SpringIOC容器

IOC—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。通俗的讲就是创建对象的

DI（Dependency Injection，依赖注入），Ioc的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection依赖注入）来实现的。给对象属性赋值

5. bean.xml配置文件标签说明

Spring（一）程序员的春天

6. SpringIOC容器创建容器几种方式

加载类路径下的配置文件创建容器（ClassPathXmlApplicationContext）

ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

加载注解类的方式创建容器（AnnotationConfigApplicationContext）

ApplicationContext ac =
                new AnnotationConfigApplicationContext(User.class);//User表示的是注解类

加载项目外部的配置文件创建容器（FileSystemXmlApplicationContext）

ApplicationContext ac = new FileSystemXmlApplicationContext("D:\\bean.xml");

7. SpringIOC容器创建对象的三种方式

方式1：默认无参数构造函数创建对象
步骤：

创建Maven项目
添加SpringIOC容器核心支持包

<dependencies>
        <!--添加SpringIOC容器核心支持包。-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
    </dependencies>

编写User实体类

public class User {
    public User(){
        System.out.println("创建User对象！");
    }
}

编写bean1.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">

    <!--
        创建User对象： User user = new User();
    -->
    <bean id="user" class="com.itheima.entity.User"></bean>
</beans>

编写测试类

import com.itheima.entity.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App1_hello {
    public static void main(String[] args) {
        // 创建容器。 SpringIOC容器 = ApplicationContext + bean1.xml
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");
        // 从容器中获取对象
        User user = (User) ac.getBean("user");
        System.out.println(user);
    }
}

方式2：工厂类的静态方法创建对象
步骤：

定义UserFactory，创建User对象
提供静态方法，创建对象

import com.itheima.entity.User;

/**
 * 创建User对象的工厂
 */
public class UserFactory {
    /**
     * 提供静态方法,返回User对象
     */
    public static User createUserByStatic(){
        System.out.println("调用工厂的static方法,创建对象!");
        return new User();
    }

    /**
     * 提供实例方法,返回User对象
     */
    public User createUser(){
        System.out.println("调用工厂的实例方法,创建对象!");
        return new User();
    }
}

配置bean2.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">

    <!--
        1) 调用工厂的静态方法创建对象加入容器
            class + factory-method 组件实现.
    -->
    <bean id="user"
          class="com.itheima.factory.UserFactory" factory-method="createUserByStatic"/>
</beans>

测试

import com.itheima.entity.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;


public class App3_ioc_obj {
    @Test
    public void ioc_classpath() {
        // 创建容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean2_ioc_obj.xml");
        // 从容器中获取对象
        User user = ac.getBean("user",User.class);
        // 测试
        System.out.println(user);
    }
}

方式3：工厂类的实例方法创建对象
步骤：

工厂类提供实例方法（在方式二中已经完成）
配置

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

    <!--
        1) 调用工厂的静态方法创建对象加入容器
            class + factory-method 组件实现.
    -->
    <bean id="user1"
          class="com.itheima.factory.UserFactory" factory-method="createUserByStatic"/>

    <!--
        2) 调用工厂的实例方法创建对象加入容器
            factory-bean + factory-method
    -->
    <bean id="factory123" class="com.itheima.factory.UserFactory"/>
    <bean id="user" factory-bean="factory123" factory-method="createUser"/>
</beans>

测试（使用方式二的测试类测试）

8. SpringIOC容器依赖注入 A 带参数构造函数

依赖注入，DI，Dependency Injection ，就是IOC容器提供的另外一块功能：给对象属性赋值。
构造器赋值

步骤：

编写Person，提供带参数构造函数
编写bean3_ioc_di.xml
编写测试

实现：

编写Person，提供带参数构造函数

package com.itheima.entity;

/**
 * 什么是javabean?
 * 1. 必须有无参数构造函数
 * 2. 必须有get或者set方法.
 */
public class Person {
    private int id;
    private String name;
    // 提供带参数构造函数
    public Person(int id,String name){
        this.id = id;
        this.name = name;
    }
    public Person(){}

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

编写bean3_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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        1)依赖注入: 通过带参数构造函数实现
        constructor-arg 给构造函数参数赋值
            value       给简单类型的属性赋值
            index       指定给第几个参数赋值,从0开始
            name        指定构造函数的形参名称,如:public Person(int id123)中的id123
            type        参数类型
            ref         参数值是引用容器中的另外的对象的id
    -->
    <bean id="person" class="com.itheima.entity.Person">
        <constructor-arg index="0" name="id" type="int" value="100"/>
        <constructor-arg index="1" ref="str"/>
    </bean>
    <!--需求: 创建一个字符串值是"球球".  String str = new String("球球");-->
    <bean id="str" class="java.lang.String">
        <constructor-arg value="球球"/>
    </bean>
</beans>

编写测试

package com.itheima;

import com.itheima.entity.Person;
import com.itheima.entity.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class App4_ioc_di {
    @Test
    public void ioc_classpath() {
        // 创建容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean3_ioc_di.xml");
        // 从容器中获取对象
        Person person = ac.getBean("person",Person.class);
        // 测试
        System.out.println(person);
    }
}

9. SpringIOC容器依赖注入 B set方法【最常用】

步骤：

Person类添加set方法
配置

实现：

Person类添加set方法

package com.itheima.entity;

/**
 * 什么是javabean?
 * 1. 必须有无参数构造函数
 * 2. 必须有get或者set方法.
 */
public class Person {
    private int id;
    private String name;
    // 提供带参数构造函数
    public Person(int id,String name){
        this.id = id;
        this.name = name;
    }
    public Person(){}

    /*提供set方法,实现给对象属性赋值*/
    public void setId(int id) {
        this.id = id;
    }
    /*提供set方法,实现给对象属性赋值*/
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

配置

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

    <!--
        1)依赖注入: 通过带参数构造函数实现
        constructor-arg 给构造函数参数赋值
            value       给简单类型的属性赋值
            index       指定给第几个参数赋值,从0开始
            name        指定构造函数的形参名称,如:public Person(int id123)中的id123
            type        参数类型
            ref         参数值是引用容器中的另外的对象的id
    -->
    <bean id="person1" class="com.itheima.entity.Person">
        <constructor-arg index="0" name="id" type="int" value="100"/>
        <constructor-arg index="1" ref="str"/>
    </bean>
    <!--需求: 创建一个字符串值是"球球".  String str = new String("球球");-->
    <bean id="str" class="java.lang.String">
        <constructor-arg value="球球"/>
    </bean>

    <!--
        2)依赖注入: 通过set方法实现依赖注入(给对象"属性"赋值)
        property 给对象顺序赋值
            name 指定对象的属性. 属性就是指get或者set方法后面的部分首字母小写
                 如: public void setId456(int id) 中的id456就是属性.
            value 指定对象属性值
            ref   指定对象属性值,值是引用容器中的另外一个对象的bean的id
    -->
    <bean id="person" class="com.itheima.entity.Person">
        <property name="id" value="16888"/>
        <property name="name" ref="str"/>
    </bean>
</beans>

10. SpringIOC容器依赖注入 C p名称空间

p名称空间

作用：简化依赖注入的配置，简化配置。

使用：

先引入p名称空间
使用它

配置代码

Person类提供set方法（已经有）

配置，通过p名称空间实现依赖注入（也是调用set方法）

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        1)依赖注入: 通过带参数构造函数实现
        constructor-arg 给构造函数参数赋值
            value       给简单类型的属性赋值
            index       指定给第几个参数赋值,从0开始
            name        指定构造函数的形参名称,如:public Person(int id123)中的id123
            type        参数类型
            ref         参数值是引用容器中的另外的对象的id
    -->
    <bean id="person1" class="com.itheima.entity.Person">
        <constructor-arg index="0" name="id" type="int" value="100"/>
        <constructor-arg index="1" ref="str"/>
    </bean>
    <!--需求: 创建一个字符串值是"球球".  String str = new String("球球");-->
    <bean id="str" class="java.lang.String">
        <constructor-arg value="球球"/>
    </bean>

    <!--
        2)依赖注入: 通过set方法实现依赖注入(给对象"属性"赋值)
        property 给对象顺序赋值
            name 指定对象的属性. 属性就是指get或者set方法后面的部分首字母小写
                 如: public void setId456(int id) 中的id456就是属性.
            value 指定对象属性值
            ref   指定对象属性值,值是引用容器中的另外一个对象的bean的id
    -->
    <bean id="person2" class="com.itheima.entity.Person">
        <property name="id" value="16888"/>
        <property name="name" ref="str"/>
    </bean>

    <!--3)依赖注入: 通过p名称空间实现依赖注入-->
    <bean id="person" class="com.itheima.entity.Person" p:id="9999" p:name-ref="str"/>
</beans>

11. SpringIOC容器(八)给集合属性赋值

步骤：

Person添加集合属性
配置

实现：

Person添加集合属性

package com.itheima.entity;

import java.util.*;

/**
 * 什么是javabean?
 * 1. 必须有无参数构造函数
 * 2. 必须有get或者set方法.
 */
public class Person {
    private int id;
    private String name;
    /*提供集合属性*/
    private String[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String,Object> map;
    private Properties properties;

    // 提供带参数构造函数
    public Person(int id,String name){
        this.id = id;
        this.name = name;
    }
    public Person(){}

    /*提供set方法,实现给对象属性赋值*/
    public void setId(int id) {
        this.id = id;
    }
    /*提供set方法,实现给对象属性赋值*/
    public void setName(String name) {
        this.name = name;
    }

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

    public void setArray(String[] array) {
        this.array = array;
    }

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

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

    public void setMap(Map<String, Object> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

}

配置

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        1)依赖注入: 通过带参数构造函数实现
        constructor-arg 给构造函数参数赋值
            value       给简单类型的属性赋值
            index       指定给第几个参数赋值,从0开始
            name        指定构造函数的形参名称,如:public Person(int id123)中的id123
            type        参数类型
            ref         参数值是引用容器中的另外的对象的id
    -->
    <bean id="person1" class="com.itheima.entity.Person">
        <constructor-arg index="0" name="id" type="int" value="100"/>
        <constructor-arg index="1" ref="str"/>
    </bean>
    <!--需求: 创建一个字符串值是"球球".  String str = new String("球球");-->
    <bean id="str" class="java.lang.String">
        <constructor-arg value="球球"/>
    </bean>

    <!--
        2)依赖注入: 通过set方法实现依赖注入(给对象"属性"赋值)
        property 给对象顺序赋值
            name 指定对象的属性. 属性就是指get或者set方法后面的部分首字母小写
                 如: public void setId456(int id) 中的id456就是属性.
            value 指定对象属性值
            ref   指定对象属性值,值是引用容器中的另外一个对象的bean的id
    -->
    <bean id="person2" class="com.itheima.entity.Person">
        <property name="id" value="16888"/>
        <property name="name" ref="str"/>
    </bean>

    <!--3)依赖注入: 通过p名称空间实现依赖注入-->
    <bean id="person3" class="com.itheima.entity.Person" p:id="9999" p:name-ref="str"/>

    <!--给集合顺序赋值-->
    <bean id="person" class="com.itheima.entity.Person">
        <!--给数组集合赋值-->
        <property name="array">
            <array>
                <value>cn</value>
                <value>usa</value>
            </array>
        </property>
        <!--给list集合赋值-->
        <property name="list">
            <list>
                <value>cn</value>
            </list>
        </property>
        <!--给set集合赋值-->
        <property name="set">
            <set>
                <value>usa</value>
            </set>
        </property>
        <!--给map集合赋值-->
        <property name="map">
            <map>
                <entry key="cn" value="China"/>
            </map>
        </property>
        <!--给properties属性赋值-->
        <property name="properties">
            <props>
                <prop key="usa">America</prop>
            </props>
        </property>
    </bean>
</beans>

上一篇： ActiveMQ的初次认识

下一篇： java study2

Spring（一）程序员的春天

1. 认识Spring框架

2. Spring的重要性

3. 解耦的好处

4. SpringIOC容器

5. bean.xml配置文件标签说明

6. SpringIOC容器创建容器几种方式

7. SpringIOC容器创建对象的三种方式

8. SpringIOC容器依赖注入 A 带参数构造函数

9. SpringIOC容器依赖注入 B set方法【最常用】

10. SpringIOC容器依赖注入 C p名称空间

11. SpringIOC容器(八)给集合属性赋值