spring 学习笔记

最新推荐文章于 2024-11-13 17:07:29 发布

Dylan_r

最新推荐文章于 2024-11-13 17:07:29 发布

阅读量160

点赞数

文章标签： spring java

本文链接：https://blog.csdn.net/weixin_46819313/article/details/116072082

版权

这篇博客详细介绍了Spring框架的核心特性，包括控制反转（IOC）和面向切面编程（AOP）。通过实例展示了如何使用XML配置和注解进行bean的创建与管理，以及如何实现AOP的切面、通知和切入点表达式。此外，还提到了Spring整合Mybatis的事务管理，强调了事务在保持数据一致性中的关键作用。

摘要由CSDN通过智能技术生成

spring 是一个开源的免费的框架（容器）
spring 是一个轻量级的、非入侵方式的框架
控制反转（IOC），面向切面编程（AOP）
支持事务的处理，对框架整合的支持

https://spring.io
https://spring.io/projects/spring-framework#learn

总结一句话：spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架。
导入

org.springframework spring-webmvc 5.1.20.RELEASE org.springframework spring-jdbc 5.1.20.RELEASE

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，
可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，
简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，
对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。
也可以说，依赖被注入到对象中

<?xml version="1.0" encoding="UTF-8"?>

    <bean id="hello" class="com.ly.pojo.Hello">
        <property name="str" value="spring"/>
    </bean>

核心就是实体类的 set方法
public void setStr(String str) {
this.str = str;
}

所谓的ioc 对象由spring来创建管理装配

第一种默认无参构造创建

第二种使用有参构造创建

public static void main(String[] args) {
// spring容器类似中介 beans.xml中被注册这里就被实例化了
ApplicationContext context =new ClassPathXmlApplicationContext(“beans.xml”);
User user = (User) context.getBean(“user”);
user.show();

    User user2 = (User) context.getBean("user");

    System.out.println(user==user2);
}

User的有参构造
UserT被创建
name=jeff
true

起别名:

进程已结束，退出代码 0

public static void main(String[] args) {

// spring容器类似中介 beans.xml中被注册这里就被实例化了
ApplicationContext context =new ClassPathXmlApplicationContext(“beans.xml”);
User user = (User) context.getBean(“useralias”);
user.show();

<!--    class bean 对象对应的全限定名：包名+类名
name 也是别名-->
<bean id="userT" class="com.ly.pojo.UserT"  name="user2">

name也可以取别名所以上面这个没啥用且可以取多个别名

import：
将多个配置文件导入合并为一个

<?xml version="1.0" encoding="UTF-8"?>

<import resource="beans.xml"/>

<bean id="student" class="com.ly.pojo.Student">
        <!--  第一种 普通值注入 直接使用value-->
    <property name="name" value="dylan"/>
        <!--  第二种 (引用注入)bean注入 使用ref-->
    <property name="address" ref="address"/>


    <!--  第三种 数组注入 -->
    <property name="books">
        <array>
            <value>红楼梦</value>
            <value>西游记</value>
            <value>水浒传</value>
        </array>
    </property>

    <!--List注入 -->
    <property name="hobbys">
        <list>
            <value>音乐</value>
            <value>代码</value>
            <value>电影</value>
        </list>
    </property>

    <!--map注入-->
    <property name="card">
        <map>
            <entry key="身份证" value="254878789696969584"/>
            <entry key="银行卡" value="303003030300303333"/>
        </map>
    </property>

    <!--set注入-->
    <property name="games">
        <set>
            <value>LOL</value>
            <value>COC</value>
            <value>BOB</value>
        </set>
    </property>

    <!--nul注入l-->
    <property name="wife">
          <null/>
    </property>

    <!--properties注入 -->
    <property name="info">
        <props>
            <prop key="学号">18756452</prop>
            <prop key="性别">man</prop>
            <prop key="姓名">小明</prop>
        </props>
    </property>
</bean>

!!!有set 方法才能注入!!!

下面的示例使用p-namespace进行更简洁的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”
加上命名空间（导入xml约束）

|   xmlns:p="http://www.springframework.org/schema/p"|
----------------------------------------------------------------
   xsi:schemaLocation="http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd">

  <bean id="user" class="com.ly.pojo.User" p:name="jack" p:age="12" />

//把上面那句前后 p 改成 c xmlns:c="http://www.springframework.org/schema/c"

单例模式（一个实例化）
通过 scrope属性设置
（默认）

public void test2(){
ApplicationContext context=new ClassPathXmlApplicationContext(“userbeans.xml”);
User user = (User) context.getBean(“user2”);
User user2 = (User) context.getBean(“user2”);

    System.out.println(user==user2);
}

结果为true
原型模式（多个实例） System.out.println(user==user2); (结果为false)

bean 的自动装配
自动装配是spring满足bean依赖的一种方式
spring会在上下文中自动寻找，并自动给bean装配属性
在spring中有三种装配模式：
1、在xml 中显式的配置
2、在java 中显式的配置
3、隐式的自动装配bean [重要]

测试：
一个人有两个宠物
ByName自动装配
//先注册两个宠物的bean!!!

	    <bean id="cat" class="com.ly.pojo.Cat"/>
		 <bean id="dog" class="com.ly.pojo.Dog"/>

                                          //autowire 自动在bean里面寻找，并自动给bean装配属性
		和自己对象set方法后面的对应的bean 的  id

		 <bean id="person" class="com.ly.pojo.Person" autowire="byName">
   			 <property name="name" value="小张"/>
	  </bean>

autowire="ByType"				
               ByType自动装配
                       和自己对象class属性相同的bean  (id都可以省略)

使用注解自动装配
The introduction of annotation-based configuration raised the question of
whether this approach is “better” than XML.

使用注解要求：
 1、导入约束 contetx约束
2、配置注解的支持
       <?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

   	 https://www.springframework.org/schema/beans/spring-beans.xsd
    	http://www.springframework.org/schema/context
   	 https://www.springframework.org/schema/context/spring-context.xsd">

	<context:annotation-config/>

</beans>
	
	@Autowired

 直接在实体类添加注解（直接在属性上使用）
  @Autowired
    private Cat cat;
  @Autowired
  private Dog dog;


使用 @Autowired 可以不用编写set方法 前提是这个
自动装配的属性在 ioc容器（spring）容器中存在且符合名字

使用注解开发
spring4 之后要使用注解开发保证 aop包导入了

org.springframework:spring-webmvc:5.2.0.RELEASE
！！！！！！org.springframework:spring-aop:5.2.0.RELEASE！！！！！！！！！！！！！
org.springframework:spring-beans:5.2.0.RELEASE
org.springframework:spring-context:5.2.0.RELEASE
org.springframework:spring-core:5.2.0.RELEASE
org.springframework:spring-expression:5.2.0.RELEASE
org.springframework:spring-web:5.2.0.RELEASE

导入约束 contetx约束、配置注解的支持。

Component组件常放置在类上，说明这个类被spring管理了也就是bean.

1、bean

@Component
public class User {
public String name=“dylan”;

}

2、注入属性
@Component
public class User {
@Value(“lucy”)
public String name;

} （简单的可以这样使用复杂的还是用配置文件）

3、衍生的注解（不同的命名方式功能都一样都是代表将某个类注册到spring容器中）
@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！
dao【@Repository】
service【@Service】
controller【@Controller】

作用域：@Scope(“property”)

@Component
@Scope(“property”)
public class User {
@Value(“lucy”)
public String name;

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

}

xml万能使用任何场合维护方便
注解有局限性

xml与注解配合
xml管理bean
注解只负责完成属性的注入
使用过程中注意必须让注解生效，也就是开启注解的支持

<context:component-scan base-package="com.ly"/>
<!--    开启注解支持-->
<context:annotation-config/>

使用java方式配置spring
完全不使用xml的配置
JavaConfig是Spring的一个子项目（在spring4之后成为核心功能）

@Configuration
public class MyConfig {
@Bean
public User getUser(){
return new User();
}
}

public class MyTest {
public static void main(String[] args) {
AnnotationConfigApplicationContext context= new AnnotationConfigApplicationContext(MyConfig.class);
User user = context.getBean(“getUser”,User.class);
System.out.println("user.getName() = " + user.getName());
}
}

package com.ly.config;

import com.ly.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@ComponentScan(“com.ly.pojo”)
@Import(MyConfig2.class)
public class MyConfig {
// 相当于之前写的bean标签这个方法的名字相当于 id属性返回值相当于class属性
@Bean
public User getUser(){
return new User();//就是返回要注入到bean的对象
}
}

public class MyTest {
public static void main(String[] args) {
// 如果完全使用配置类方式去做我们只能通过AnnotationConfig上下文来获取容器通过配置类的class对象加载！
AnnotationConfigApplicationContext context= new AnnotationConfigApplicationContext(MyConfig.class);
User user = context.getBean(“getUser”,User.class);
System.out.println("user.getName() = " + user.getName());
}
}

这种纯java的配置方式，在springboot中随处可见！！！

代理模式
因为这就是springAOP的底层【Spring Aop 和 Spring mvc】

 代理模式的分类

  静态代理
  动态代理

1静态代理：

代码步骤：
              1、接口
              2、真实角色
3、代理角色
3、客户端访问代理角色



代理模式的好处：
        可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
       公共也就交给了代理角色，实现了业务的分工
      公共业务发生扩展的时候，放便集中管理！
缺点：一个真实角色就会产生一个代理角色  代码量会翻倍（开发效率变低）

Client （客户（测试））
UserService（接口）
UserServiceImpl（实现接口）
UserServiceProxy（代理实现接口实现）

2、动态代理（反射机制）
动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是直接写的。
动态代理分为两大类
基于接口的动态代理 --JDK动态代理【用这个】
基于类的动态代理-----cglib

固定写法相当于工具类：

package com.ly.demo04;

import com.ly.demo03.Rent;

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

// y用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

//被代理的接口
private  Object target;

public void setTarget(Object target) {
    this.target = target;
}

//生成得到代理类
public Object getProxy(){
   return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
}


//处理代理实例并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     //动态代理的本质就是使用反射机制实现
    log(method.getName());
    Object result = method.invoke(target, args);

    return  result;
}

public void log(String msg){
    System.out.println("执行了"+msg+"方法");
}

}

测试：

public class Client {
public static void main(String[] args) {
//真实角色
UserServiceImpl userService=new UserServiceImpl();
//代理角色不存在
ProxyInvocationHandler PIH = new ProxyInvocationHandler();

    PIH.setTarget(userService);//设置要代理的对象
    // 通过 接口  动态生成代理类
    UserService proxy = (UserService) PIH.getProxy();
    proxy.update();

}

}

动态代理好处
静态代理的优点它都有
！！！一个动态代理类代理的是一个接口，一般就是一类业务！！！

AOP
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，
通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，
是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，
提高程序的可重用性，同时提高了开发的效率。

使用spring实现aop
导入一个依赖包

org.aspectj
aspectjweaver
1.9.4

方式一：使用spring的 API 接口

    xmlns:aop="http://www.springframework.org/schema/aop"
   http://www.springframework.org/schema/aop
    https://www.springframework.org/schema/aop/spring-aop.xsd

（导入aop约束）

方式二自定义类

//自定义切面类
public class DiyPointCut {
public void before(){
System.out.println(“方法执行前=====”);
}

public void after(){
    System.out.println("==========方法执行后===============");
}

}

aop:config

<aop:aspect ref=“diy”>

<aop:pointcut id=“point” expression=“execution(* com.ly.service.UserServiceImpl.*(…))”/>

<aop:before method=“before” pointcut-ref=“point”/>
<aop:after method=“after” pointcut-ref=“point”/>
</aop:aspect>
</aop:config>

方式三：注解

//标注这个类为一个切面
@Aspect
public class AnnotationPointCut {
@Before(“execution(* com.ly.service.UserServiceImpl.*(…))”)
public void before(){
System.out.println("=方法执行前（注解)======");
}

<bean id="annotationPointCut" class="com.ly.diy.AnnotationPointCut"/>

aop:aspectj-autoproxy/

整合 Mybatis
步骤：
导入相关jar包
编写配置文件
测试

简介
什么是 MyBatis-Spring？
MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许
MyBatis 参与到 Spring 的事务管理之中，创建映射器 mapper 和 SqlSession 并注入到 bean 中，
以及将 Mybatis 的异常转换为 Spring 的 DataAccessException。最终，可以做到应用代码不依赖于
MyBatis，Spring 或 MyBatis-Spring。

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</bean>

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <!-- 绑定mybatis配置文件-->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <property name="mapperLocations" value="classpath:com/ly/mapper/UserMapper.xml"/>
</bean>

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">

    <constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>

<bean id="userMapper" class="com.ly.mapper.UserMapperImpl">
    <property name="sqlSession" ref="sqlSession"/>
</bean>

5、将自己写的实现类，注入到spring中测试。

！！！！！！！
//spring 整合mybatis之后多了一个XXXImpl实现类因为spring要去接管对象自动创建而mybatis无法自动创建（手动设置set方法）
public class UserMapperImpl implements UserMapper {

//原来所有操作都是用sqlSession来执行 现在使用sqlSessionTemplate
private SqlSessionTemplate sqlSession;

public void setSqlSession(SqlSessionTemplate sqlSession) {
  this.sqlSession = sqlSession;

}

public List<User> selectUser() {
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   return mapper.selectUser();
}

}

第二种直接继承（简化操作）(还是第一种只是通过继承简化了)
SqlSessionDaoSupport 是一个抽象的支持类，用来为你提供 SqlSession。
调用 getSqlSession() 方法你会得到一个 SqlSessionTemplate，之后可以用于执行 SQL 方法，

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
public List selectUser() {
return getSqlSession().getMapper(UserMapper.class).selectUser();
}
}

重点第一种!!!

辅助工具（插件）（mybatis-plus 通用mapper）

声明式事务
事务
all fail or all success
事务在项目开发中，涉及到数据的一致性问题。
确保完整性和一致性

事务的ACID原则
原子性
一致性
隔离性
多个业务可能操作同一个数据防止数据损坏
持久性
事务一旦提交，无论发生什么问题，结果都不会被影响，被持久化的写到存储器中

spring中的事务管理
声明式事务管理 AOP
编程式事务管理（需要在代码中进行事务的管理）

在声明式的事务处理中，要配置一个切面，即一组方法，如

<tx:advice id="txAdvice" transaction-manager="txManager">
	<tx:attributes>
	    <tx:method name="find*" read-only="true" propagation="NOT_SUPPORTED" />
	</tx:attributes>
</tx:advice>

其中就用到了propagation，表示打算对这些方法怎么使用事务，是用还是不用，其中propagation有七种配置，REQUIRED、SUPPORTS、MANDATORY、REQUIRES_NEW、NOT_SUPPORTED、NEVER、NESTED。默认是REQUIRED。
2.七种配置
下面是Spring中Propagation类的事务属性详解：

REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。

MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。

REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。

NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

NESTED：支持当前事务，如果当前事务存在，则执行一个嵌套事务，如果当前没有事务，就新建一个事务。
3.注意
这个配置将影响数据存储，必须根据情况选择。

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <constructor-arg ref="dataSource" />
</bean>

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!--给哪些方法配置事务-->
    <!--配置事务的传播特性 new-->
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:pointcut id="txPointCut" expression="execution(* com.ly.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>

//实现类
//spring 整合mybatis之后多了一个XXXImpl实现类因为spring要去接管这个对象自动创建而mybatis无法自动创建（手动设置set方法）
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {

public List<User> selectUser() {
    User user = new User(22, "this", "0202020");
    UserMapper mapper=getSqlSession().getMapper(UserMapper.class);
    mapper.addUser(user);
    mapper.deleteUser(22);

    return mapper.selectUser();

}

public int addUser(User user) {
    return getSqlSession().getMapper(UserMapper.class).addUser(user);
}

public int deleteUser(int id) {
    return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
}

}
(这样如果delete方法有错误整个事务不会成功如果不配置事务那插入方法就会成功而删除方法不会成功)
违背了事务原则！

如果不配置事务可能存在数据提交不一致的情况。

事务非常重要！！！