Spring5学习笔记

最新推荐文章于 2025-06-15 17:45:58 发布

csdn_bobo_6

最新推荐文章于 2025-06-15 17:45:58 发布

阅读量111

点赞数

文章标签：学习 java spring

本文链接：https://blog.youkuaiyun.com/csdn_bobo_6/article/details/127825281

版权

框架概述

1、轻量级的开源的JavaEE框架
2、Spring可以解决企业应用开发的复杂性
3、Spring有两个核心部分:IOC和Aop， IOC 控制反转，把创建的对象交给Spring进行管理；AOP面向切面，不修改源代码进行功能的增强

特点

1、方便解耦，简化开发
2、Aop变成的支持
3、方便测试（集成Junit）
4、方便和其他框架进行整合
5、方便进行事务操作
6、降低API的开发难度

下载地址

https://repo.spring.io/ui/native/release/org/springframework/spring

IOC

说明:控制反转，把对象的创建和对象之间的调用过程，交给spring管理，使用目的是为了降低耦合度

底层原理实现方式：xml解析、工厂模式、反射

解耦过程：

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

<bean id="" class="" />

第二步：有service类，dao类，创建工厂类

Class DaoFactory{
    public static UserDao getDao() {
    	String classValue = class属性值； //xml解析
	    Class clazz = Class.fromClass(ClassValue); //通过反射创建对象
	    return （UserDao）clazz.newInstance;
    }
}

接口：

1、IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
2、spring提供了IOC容器实现的两种方式：（两个接口）

BeanFactory

IOC容器基本实现，是Spring内部使用的接口
特点：加载配置文件的时候不会创建对象，在获取（使用）对象的时候才会创建

ApplicationContext

BeanFactory接口的子接口，提供了更多的更强大的功能，一般由开发人员进行使用
特点：加载配置文件的时候，就会把对象创建

ApplicationContext中主要的实现类：
FileSystemXMLApplicationContext：要把xml的项目路径写下来（本地路径）
ClassPathXMLApplicationContext

IOC操作Bean管理

什么是Bean管理：
Bean管理指的是两个操作：
Spring创建对象
spring注入属性

Spring创建对象(XML)

Bean管理操作有两种方式:
基于xml配置文件方式实现
<bean id="" class=""/>
在配置文件中加入bean标签
bean标签常用属性
id：唯一标识
class：创建对象的全路径
name:和id操作一样，区别是可以加特殊符号

spring注入属性(XML)

基于xml方式注入属性
DI：依赖注入，就是注入属性
    DI是IOC的一种实现
注入方式：
1、set注入 Spring xml 配置实现  <property name="" value="" />注入 
2、有参构造  Spring xml 配置实现<constructor-arg name(index也可以用索引和name一样 不过index使用0,1)="" value="" ></constructor-arg>
3、P名称空间注入，可以简化基于xml配置方式 
在xml中加入p约束 在创建方法的时候加入
<bean name="" value="" p:赋值字段/>

xml注入其他类型属性
字面量（设置固定值）：
null值
<property name="" ><null/></property>

属性值中包含特殊符号
xml中的CDATA
<property name="" >
   <value><![CDATA["放特殊值 如：《123》，￥34’"]]></value>
</property>

注入属性：
注入外部bean（三层架构实现）
创建service，dao对象
<bean id='service' class=''>
    service掉调用Bean对象
    <property name='' ref(所调用对象的id)='dao'></property>
</bean>
<bean id='dao' class=''>
	<property name='' value=''/>
</bean>

注入内部bean
<bean id='' class=''>
	<property name=''>
		<bean id='' class=''>
			<property name='' value=''></property>
		</bean>
	</property>
</bean>

级联赋值
两种写法 ：
1、和注入外部bean一样
2、 <bean id='' class=''>
		<property name='dept.deptName' value=''></property>
	</bean>
	
注入集合属性
1、注入数组
<bean id='' class=''>
	<property name=''>
		<array>
			<value></value>
			<value></value>
		</array>
	</property>
</bean>
2、注入List
<bean id='' class=''>
	<property name=''>
		<list>
			<value></value>
			<value></value>
		</list>
	</property>
</bean>
3、注入Map	
<bean id='' class=''>
	<property name=''>
		<map>
			<entry key='' value=''/>
			<entry key='' value=''/>
		</map>
	</property>
</bean>
3、注入Set
<bean id='' class=''>
	<property name=''>
		<set>
			<value></value>
			<value></value>
		</set>
	</property>
</bean>

在集合里边设置对象类型值
<bean id='' class=''>
	<property name=''>
		<list>
			<ref bean='a'></ref>
			<ref bean='b'></ref>
		</list>
	</property>
</bean>

<bean id='a' class=''>
	<property name='' value=''>
</bean>

<bean id='b' class=''>
	<property name='' value=''>
</bean>

抽取集合注入部分
1、在spring配置文件中引入名称空间util,就是引入约束
2、使用util标签实现抽取
<util:list id='util'> 
	<value></value>
	<value></value>
</util:list>

<bean id='' class=''>
	<property name='' ref='util'></property>
</bean>

Spring有两种类型的bean，一种普通bean，一种工厂bean（FactoryBean）
普通bean：在配置文件中，定义的类型就是返回的类型
工厂bean：返回的类型和定义的类型可以不一致

实现（工厂bean）：
对象实现FactoryBean 通过getObject方法定义返回的bean

bean的作用域：
1、在spring中可以设置bean是一个单实例还是多实例
2、默认情况下，bean是单实例（输出对象地址一样）
3、如何设置单实例，还是多实例，通过bean标签里边的scope属性进行设置

scope属性值：
默认值（单实例）：singleton 单实例对象
多实例值：prototype 多实例对象
singleton和prototype区别一个单实例，一个多实例设置singleton的时候，加载配置文件的时候就会创建对象, 设置prptotype,在调用getBean的时候进行创建

bean的生命周期（从对象创建到销毁的过程）
1、通过构造器创建bean实例（默认无参构造）
2、为bean的属性设置值和对其他bean引用（调用set方法）
3、把bean的实例传递给bean的后置处理器的方法（postProcessBeforeInitialization）
4、调用bean的初始化方法（需要进行配置）
5、bean实例传递bean后置处理的方法（postProcessAfterInitialization）
6、使用bean（对象获取到了）
7、当容器关闭的时候，调用bean的销毁的方法（需要配置销毁方法）

<bean id='' class='' init-method='初始化方法' destory-method='销毁的方法'></bean>

package com.bobo.spring5;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class Bean后置处理器 implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

xml自动装配
自动装配：根据指定的装配规则（属性名称或者属性类型），spring将匹配的属性进行自动装配。
实现：bean标签中的autowire属性，配置自动装配
autowire常用的两个值：
byName根据属性名注入，注意注入的bean的id值要和实体中的属性名相同。
byType根据属性类型注入

外部属性文件（以数据库配置文件为例）
<context:property-placeholder location=“外部文件” />

<!-- 获取到jdbc配置文件 -->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="driverClassName" value="${jdbc.driverClassName}" />
    </bean>

基于注解方式实现基于注解方式实现对象的创建 spring针对bean管理，创建对象提供的注解有： @Component 通用
@Service 业务逻辑层
@Controller web层
@Repository Dao层
上边的注解功能都是一样的，都可以用来创建bean实例
实现方式：
第一步：导入AOP的包
第二步：开启包扫描
<context:component-scan base-package=“com.bobo.spring5.TestSpring” />
第三步：在创建类上边添加注解

基于注解方式实现属性注入
@AutoWired 根据属性类型进行自动装配
@Qualifier 根据属性名称进行注入，要和@AutoWired一起使用
@Resource 可以根据类型注入，可以根据名称注入
@Value：注入普通类型属性

完全注解开发创建配置类，替代xml文件

package com.bobo.spring5.TestSpring.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

//全注解配置类
@Configuration
@ComponentScan(basePackages = {"com.bobo.spring5.TestSpring"}) //相当于<context:component-scan base-package="com.bobo.spring5.JdbcTemplate" />
@EnableAspectJAutoProxy(proxyTargetClass = true) //(相当于配置文件中的 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>)
public class SpringConfig {
}

AOP

概念：面向切面编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，同时提高了开发效率。
简单的说就是不修改原有代码，在主干代码中加入新的模块

底层原理：使用了动态代理有两种情况的动态代理
第一种：有接口的情况，使用JDK代理
有接口类的话，创建该接口实现类的代理对象，通过创建的代理对象对功能进行增强
JDK动态代理实现方式
1、创建接口，定义方法
2、创建接口实现类，实现方法
3、使用Proxy类创建接口代理对象

第二种：没有接口的情况，使用CGLIB代理创建当前子类的代理对象，增强类里边的方法

package 动态代理;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class ProxyTest {

    /**
     * JDK动态代理实现方式
     * 1、创建接口，定义方法
     * 2、创建接口实现类，实现方法
     * 3、使用Proxy类创建接口代理对象
     * @param args
     */
    public static void main(String[] args) {

        Class[] classes = {UserDao.class};
//        使用方法
//        newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h)
//        返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。
        UserDao userDao = new UserDaoImpl();
        UserDao userDao1 = (UserDao) Proxy.newProxyInstance(ProxyTest.class.getClassLoader(), classes, new UserDaoProxyHandler(userDao));
        //int result = userDao1.add(1, 2);
        String name = userDao1.update("苍老师");
        System.out.println("result ： ：" + name);
    }
}

class UserDaoProxyHandler implements InvocationHandler {

    //有参构造器 加入信息 要传要实现增强的接口
    private Object object;
    public UserDaoProxyHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("在实现类前增强方法。。。。 ：： method：" + method.getName() + " : : 参数信息：" + Arrays.toString(args));

        Object invoke = method.invoke(object, args);

        System.out.println("在实现类后增强方法。。。。 ：： object：" + object );

        return invoke;
    }
}

AOP开发中的相关术语：
1、连接点：类里边哪些方法可以被增强，那么这些方法就是连接点
2、切入点：实际被真正增强的方法就是切入点
3、通知（增强）：
1）实际增强的逻辑部分称为通知
2）通知有多种类型
*前置：方法前执行
*后置：方法后执行
*环绕：方法前后都执行
*异常：方法异常执行
*最终：不管有没有异常都执行
4、切面：把通知应用到切入点的过程

操作
1、spring框架中一般基于AspectJ（不是Spring组成部分，独立AOP框架，一般和Spring一起使用，进行AOP操作）实现AOP操作

基于AspectJ实现AOP操作

注：切入点表达式
作用：知道对哪个类里边的哪个方法进行增强
语法解构：
execution([权限修饰符][返回类型][类全路径][方法名称] ([参数列表]))
execution(* com.bobo.spring5.AspectjAop.UserDao.add(..))

基于注解方式实现对AspectJ的操作

1、创建类，在类里边定义一个方法

2、创建增强类（编写增强逻辑）

在增强类中定义不同的通知（前置、后置、环绕、异常、最终）

3、进行通知的配置

在spring配置文件中，开启注解扫描
使用注解创建，类和增强类的对象
在增强类上加入@Aspect注解
在spring配置文件中开启生成代理对象

4、配置不同类型的通知

在增强类里边，在作为通知的方法上添加通知类型注解，使用切入点表达式进行配置
注：
前置注解@Before(value=“execution(* )”)
最终通知注解@After(在方法之后执行，也叫最终通知)
后置注解@AfterReturning（在方法返回结果后执行）
环绕注解@Around（在方法参数中需要加ProceedingJoinPoint参数）
异常注解@AfterThrowing

5、细节

相同切入点抽取在公共方法上加@PointCut(value = “execution(* )”)注解
有多个增强类，可以设置增强类优先级在增强类上加@Order(数字类型值)

package com.bobo.spring5.AspectjAop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component //注解方式创建对象
@Aspect
public class AspectjProxy {

    //实现通知，就是要增强的代码
    //前置
    @Before(value = "execution(* com.bobo.spring5.AspectjAop.UserDao.add(..))")
    public void befor(){
        System.out.println("我是前置通知。。。。");
    }

    //后置
    @AfterReturning(value = "execution(* com.bobo.spring5.AspectjAop.UserDao.add(..))")
    public void afterReturning(){
        System.out.println("我是后置通知，也叫返回结果通知。。。。");
    }

    //最终
    @After(value = "execution(* com.bobo.spring5.AspectjAop.UserDao.add(..))")
    public void after(){
        System.out.println("我是最终。。。");
    }

    //异常
    @AfterThrowing(value = "execution(* com.bobo.spring5.AspectjAop.UserDao.add(..))")
    public void afterThrowing() {
        System.out.println("我是异常。。。");
    }

//    //环绕
    @Around(value = "execution(* com.bobo.spring5.AspectjAop.UserDao.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("我是环绕前。。。");
        Object proceed = proceedingJoinPoint.proceed();
        System.out.println("我是环绕后。。。");
    }

}

基于xml配置文件实现

1、实现bean创建对象
2、配置AOP增强

<aop:config>
		<!-- 切入点 -->
		<aop:pointcut id='p' experssion='execution(*)' />
		<!-- 配置切面 -->
		<aop:aspect ref='增强类bean id'>
			<!-- 配置通知 -->
			<aop:befor method='' pointcut-ref='p' />
		</aop:aspect>
</aop:config>

JdbcTemplate

概念：Spring框架对JDBC进行了封装，使用JdbcTemplate方便对数据库操作

实现：
1、导入jar包
2、配置xml 包括数据源对象和JdbcTemplate对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!-- 开启包扫描 -->
    <context:component-scan base-package="com.bobo.spring5.JdbcTemplate" />

    <!-- 获取到jdbc配置文件 -->
    <context:property-placeholder location="classpath:jdbc.properties" />

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="driverClassName" value="${jdbc.driverClassName}" />
    </bean>

    <!-- 配置JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource" />
    </bean>

</beans>

添加操作实例

 //添加
    public void insertBook(Book book) {
        String sql = "insert into b_book values(?,?,?)";
        //数组传值
        Object[] args = {book.getId(), book.getbName(), book.getbAutor()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

spring事务

概念：事务是数据操作最基本单元逻辑上的一组操作，要么都成功，如果有一个失败所有操作都失败

特性（ACID特性）

原子性：要么都成功，要么都失败
一致性：操作前后总量是一致的
隔离性：多事务操作不会产生影响
持久性：提交事务后，数据表发生变化

注解：

@Transactional(propagation = Propagation.SUPPORTS,isolation = Isolation.READ_UNCOMMITTED ,
        timeout = 10,readOnly = true,rollbackFor = {Exception.class})

其他内容

传播行为(propagation)：当一个事务方法被另一个事务方法调用的时候其中包括七种传播行为
其中三种比较常见
1、required 被调用的事务方法一同使用调用方法的事务
2、required_new 被调用的事务方法和调用的事务方法两者互不影响
3、support
隔离级别(isolation):事务有特性为隔离性，多事务操作之间不会产生影响，不考虑隔离性会产生很多问题
read uncommitted(读未提交) 三种问题什么都没解决
read committed(读以提交) 解决了脏读的问题
repeatable read (可重复读) 解决了脏读、不可重复读的问题
serializable(串行化) 解决了三种问题
超时时间(timeout):事务需要在一定时间内进行提交，如不提交进行回滚默认值是-1，可自己设置，以秒为单位
回滚（rollbackFor）：设置出现那些异常进行回滚
不会滚（norollbackFor）：设置出现那些异常不进行回滚
是否只读（readOnly）：
默认值FALSE 表示可以查询，可以添加修改删除操作
默认值赋值为TRUE时只可查询