Spring知识点整理

原创

阿呆狐狸 2022-03-29 09:00:16 博主文章分类：J2EE 知识 ©著作权

文章标签 j2ee知识点总结 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者阿呆狐狸的原创作品，请联系作者获取转载授权，否则将追究法律责任

一、spring概述

1、什么是spring :

spring 是开源的JAVA SE/EE全栈轻量级开源框架，以ioc（控制反转）和aop（面向切面编程）为内核

2、spring 的优势;

方便解耦，简化开发

通过spring 的ioc容器，可以将对象间的依赖关系交由spring 管理，避免硬编码造成的过度耦合，用户也不必为单例模式类、属性文件解析等很底层的需求编写代码，可以更专注于更上层的应用。将对象的创建权交给spring完成，不用去new ，减少了耦合度。

aop编程的支持

通过aop功能，方便面向切面编程。（切面编程的功能大概是在完成某个功能1的同时将另外一个功能2以在功能1之前、之后、环绕这三种方式切入，功能2叫做切面，功能1叫做切点）

声明式事务的支持

通过声明式事务管理，提高了开发效率（通过配置的方式可以很快的进行事务管理，不用再手动提交事务等）

方便程序的测试

可以用非容器依赖的方式进行几乎所有的测试工作。

方便集成各种优秀的框架

spring对多种框架都支持。

降低JAVAEE API 的使用难度

spring对JAVAEE API 进行了封装，降低了API的使用难度

Java源码是经典的学习典范

源码写得棒极了！！可以学习一下

二、spring的快速入门

1、spring的开发步骤

导入spring 的依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
        <!--log4j的日志文件-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>

//spring常用依赖
<properties>
    <org.springframework.version>4.3.19.RELEASE</org.springframework.version>
    <commons-logging.version>1.2</commons-logging.version>
    <junit.version>4.12</junit.version>
</properties>

<dependencies>
    <!-- Spring核心依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    <!-- Spring beans包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    <!-- Spring 容器包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    <!-- Spring容器依赖包,将第三方库整合进Spring应用上下文,提供支持 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    <!-- Spring aop依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    <!-- Spring aspects依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    <!-- aspectj依赖 -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.9.4</version>
    </dependency>


    <!-- commons-logging依赖 -->
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>${commons-logging.version}</version>
    </dependency>

    <!-- Spring jdbc依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    <!--Spring事物依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>

    <!-- Spring web依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    <!--Spring webmvc依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>
    <!-- Spring test依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${org.springframework.version}</version>
    </dependency>

    <!-- junit 单元测试依耐 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit.version}</version>
        <scope>test</scope>
    </dependency>
</dependencies>

User 类的创建---->UserDao的创建---->UserDaoImpl的创建---->.xml配置文件---->将UserDaoImpl配置到.xml文件中---->UserDao userDao = spring客户端.getBean(id标识)返回对象，完成解耦操作---->spring读取配置文件---->根据id 标识获取Bean的全限定名---->通过反射创建Bean对象---->返回Bean对象

2、spring配置文件：

2.1 Bean标签的基本配置：

用于配置对象交给spring来创建
默认情况下它调用的是类中的无参构造函数，没有无参构造方法则创建不成功
id为唯一标识，class为全限定类名

2.2 Bean标签的范围配置

singleton :默认值、单例的（共享bean 对象）
prototype:多例的（创建有多少个bean 对象就有对少个，不共享）
request：在web项目中创建一个bean 对象将它放在request域中
session：在web项目中创建一个bean 对象将它放在session域中
global session：在wen项目中，应用在portlet环境，如果没有protlet环境，相当于session

注：singleton 创建Bean是在加载配置文件时，只有当应用卸载或者容器销毁时Bean才会被销毁，prototype创建Bean是在getBean()时创建，当对象长时间不用是，会被java 虚拟机回收。

2.3 Bean 的生命周期配置

init-method：指定类中初始化方法的名称
destroy-method：指定类中销毁方法的名称

2.4 Bean实例化的三种方式：

无参构造方法实例化
工厂静态方法实例化

//在factory.StaticFactory.java 中：
public static UserDao getUserDao(){
        return new UserDaoImpl();
    }

//在ApplicationConfig.xml中
 <bean id="userDdao" class="cn.edu.hcnu.factory.StaticFactory" factory-method="getUserDao">
 </bean>

工厂实例方法实例化

//在factory.Dinamic.java 中
public UserDao getUserDao(){
        return new UserDaoImpl();
    }

//在Applicationconfig.xml中
<bean id="factory1" class="cn.edu.hcnu.factory.DynamicFactory"/>
<bean id="userDao" factory-bean="factory1" factory-method="getUserDao">
</bean>

2.5 Bean 的依赖

什么是依赖注入：它是spring框架核心ioc的具体实现
怎么依赖注入：在编写程序时，通过控制反转，把对象的创建权交给spring，但是代码中还是会有依赖，IOC解耦只是降低了他们之间的依赖关系，但是不会消除。例如业务层和持久层之间的关系，这种业务层和持久层之间的关系，在使用spring之后就交给spring来维护了，让spring框架将业务层对象传给持久层，而不用自己去获取。
实现依赖注入的方式：构造方法、set方法

（1）set的方式：

//在UserDaoImpl 中写上setUserDao 的set方法
private UserDao userDao;

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

//在application.xml 中：
<bean id="userDao" class="cn.edu.hcnu.dao.impl.UserDaoImpl">
            <property name="userDao" ref="userDao"></property>
        </bean>

//在TestUser中：
 ApplicationContext app = new ClassPathXmlApplicationContext("application.xml");
        UserDaoImpl userDao = (UserDaoImpl) app.getBean("userDao");
        userDao.find();

P命名空间注入（本质上也是set方式注入）：

注意：在application.xml 中将<beans>标签里的

xmlns="http://www.springframework.org/schema/beans 改成：

xmlns:p="http://www.springframework.org/schema/p"

//在application.xml中：
<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"
       xmlns:p="http://www.springframework.org/schema/p">
    <bean id="userDao" class="cn.edu.hcnu.dao.impl.UserDaoImpl" p:userDao-ref="userDao"></bean>
</beans>

//在UserDaoImpl 中：
private UserDao userDao;

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

在TestUser 中：
 ApplicationContext app = new ClassPathXmlApplicationContext("application.xml");
        UserDaoImpl userDao = (UserDaoImpl) app.getBean("userDao");
        userDao.find();

构造方法：（有参构造）

//在UserDaoImpl 中生成有参无参构造
public UserDaoImpl() {
    }

    public UserDaoImpl(UserDao userDao) {
        this.userDao = userDao;
    }

//在application.xml 中：
 <bean id="userDao1" class="cn.edu.hcnu.dao.impl.UserDaoImpl"></bean>
    <bean id="userDao" class="cn.edu.hcnu.dao.impl.UserDaoImpl">
            <constructor-arg name="userDao" ref="userDao1"></constructor-arg>
    </bean>

//在testUser中：
ApplicationContext app = new ClassPathXmlApplicationContext("application.xml");
        UserDaoImpl userDao = (UserDaoImpl) app.getBean("userDao");
        userDao.find();

注意：set 方式的name 为set 方法的参数名

构造方式的name 为构造内部的参数名，ref 后的userDao 表示引用容器中的bean

(未完待续)