Spring学习

已于 2022-09-09 20:53:08 修改
阅读量239 收藏
点赞数
分类专栏： java开发 文章标签： spring java
于 2022-09-06 15:47:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40843007/article/details/126694333
版权

文章图片资料来源黑马程序员java视频课程，仅供个人学习参考。

Spring技术

Spring发展史

在这里插入图片描述

Spring特点

简化开发

  1. IoC
  2. AOP

框架整合

Spring Framework系统架构

在这里插入图片描述

核心概念

在这里插入图片描述

IoC、DI案例

//1.导入Spring坐标（pom.xml）
 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
//2.配置bean
  <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <!--7.配置server与dao的关系-->
        <!--property标签表示配置当前bean的属性
        name属性表示配置哪一个具体的属性
        ref属性表示参照哪一个bean-->
        <property name="bookDao" ref="bookDao"/>
    </bean>
//3.获取Ioc容器
   ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//4.获取Bean
   BookService bookService = (BookService) ctx.getBean("bookService");

//service依赖于dao
public class BookServiceImpl implements BookService {
    //5.删除业务层中使用new的方式创建的dao对象
    private BookDao bookDao;

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //6.提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

Bean配置

在这里插入图片描述

<?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-->
<!--    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>-->


    <!--方式二：使用静态工厂实例化bean-->
<!--    <bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>-->

    <!--方式三：使用实例工厂实例化bean-->
<!--    <bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>

    <bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>-->

    <!--方式四：使用FactoryBean实例化bean-->
    <bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>

</beans>

在这里插入图片描述

DI依赖自动装配

<?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 class="com.itheima.dao.impl.BookDaoImpl"/>
    <!--autowire属性：开启自动装配，通常使用按类型装配-->
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>

</beans>
  1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作
  2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
  3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
  4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

集合注入

<?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="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <!--数组注入-->
        <property name="array">
            <array>
                <value>100</value>
                <value>200</value>
                <value>300</value>
            </array>
        </property>
        <!--list集合注入-->
        <property name="list">
            <list>
                <value>itcast</value>
                <value>itheima</value>
                <value>boxuegu</value>
                <value>chuanzhihui</value>
            </list>
        </property>
        <!--set集合注入-->
        <property name="set">
            <set>
                <value>itcast</value>
                <value>itheima</value>
                <value>boxuegu</value>
                <value>boxuegu</value>
            </set>
        </property>
        <!--map集合注入-->
        <property name="map">
            <map>
                <entry key="country" value="china"/>
                <entry key="province" value="henan"/>
                <entry key="city" value="kaifeng"/>
            </map>
        </property>
        <!--Properties注入-->
        <property name="properties">
            <props>
                <prop key="country">china</prop>
                <prop key="province">henan</prop>
                <prop key="city">kaifeng</prop>
            </props>
        </property>
    </bean>
</beans>

核心容器

  • BeanFactory是IoC容器的顶层接口，初始化BeanFactory对象时，加载的bean延迟加载
  • ApplicationContext接口是Spring容器的核心接口，初始化时bean立即加载
  • ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能
  • ApplicationContext接口常用初始化类
    • ClassPathXmlApplicationContext(常用)
    • FileSystemXmlApplicationContext
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

Bean在这里插入图片描述

依赖注入

在这里插入图片描述

纯注解开发

创建配置类SpringConfig

//在配置类上添加`@Configuration`注解，将其标识为一个配置类,替换`applicationContext.xml`
@Configuration
//在配置类上添加包扫描注解`@ComponentScan`替换`<context:component-scan base-package=""/>`
@ComponentScan("com.itheima")
public class SpringConfig {
}

public class AppForAnnotation {

    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao);
        BookService bookService = ctx.getBean(BookService.class);
        System.out.println(bookService);
    }
}

Bean生命周期

package com.itheima.dao.impl;

import com.itheima.dao.BookDao;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Repository
//@Scope设置bean的作用范围
@Scope("singleton")
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println("book dao save ...");
    }
    //@PostConstruct设置bean的初始化方法
    @PostConstruct
    public void init() {
        System.out.println("init ...");
    }
    //@PreDestroy设置bean的销毁方法
    @PreDestroy
    public void destroy() {
        System.out.println("destroy ...");
    }

}

注解实现依赖注入

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    @Qualifier("bookDao1")
    private BookDao bookDao;
    
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

第三方Bean

public class JdbcConfig {
    //1.定义一个方法获得要管理的对象
    @Value("com.mysql.jdbc.Driver")
    private String driver;
    @Value("jdbc:mysql://localhost:3306/spring_db")
    private String url;
    @Value("root")
    private String userName;
    @Value("root")
    private String password;
    //2.添加@Bean，表示当前方法的返回值是一个bean
    //@Bean修饰的方法，形参根据类型自动装配
    @Bean
    public DataSource dataSource(BookDao bookDao){
        System.out.println(bookDao);
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

在这里插入图片描述

Spring整合mybatis

// 1.导入坐标
 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>
 
//2.jdbcConfig
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

//2.springConfig
@Configuration
@ComponentScan("com.itheima")
//@PropertySource：加载类路径jdbc.properties文件
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}

//3.mybatisConfig
public class MybatisConfig {
    //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    //定义bean，返回MapperScannerConfigurer对象
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

Spring整个junit

//设置类运行器
@RunWith(SpringJUnit4ClassRunner.class)
//设置Spring环境对应的配置类
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    //支持自动装配注入bean
    @Autowired
    private AccountService accountService;

    @Test
    public void testFindById(){
        System.out.println(accountService.findById(1));

    }

    @Test
    public void testFindAll(){
        System.out.println(accountService.findAll());
    }


}

AOP(面向切面编程)

作用：在不惊动原始设计的基础上为其功能增强
在这里插入图片描述

AOP工作流程

在这里插入图片描述
在这里插入图片描述

AOP切入点表达式

@Component
@Aspect
public class MyAdvice {
    //切入点表达式：
//    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
//    @Pointcut("execution(void com.itheima.dao.impl.BookDaoImpl.update())")
//    @Pointcut("execution(* com.itheima.dao.impl.BookDaoImpl.update(*))")    //no
//    @Pointcut("execution(void com.*.*.*.update())")
//    @Pointcut("execution(* *..*(..))")
//    @Pointcut("execution(* *..*e(..))")
//    @Pointcut("execution(void com..*())")
//    @Pointcut("execution(* com.itheima.*.*Service.find*(..))")
    //执行com.itheima包下的任意包下的名称以Service结尾的类或接口中的save方法，参数任意，返回值任意
    @Pointcut("execution(* com.itheima.*.*Service.save(..))")
    private void pt(){}

    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

在这里插入图片描述

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}
    @Pointcut("execution(int com.itheima.dao.BookDao.select())")
    private void pt2(){}

    //@Before：前置通知，在原始方法运行之前执行
//    @Before("pt()")
    public void before() {
        System.out.println("before advice ...");
    }

    //@After：后置通知，在原始方法运行之后执行
//    @After("pt2()")
    public void after() {
        System.out.println("after advice ...");
    }

    //@Around：环绕通知，在原始方法运行的前后执行
//    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around before advice ...");
        //表示对原始操作的调用
        Object ret = pjp.proceed();
        System.out.println("around after advice ...");
        return ret;
    }

//    @Around("pt2()")
    public Object aroundSelect(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("around before advice ...");
        //表示对原始操作的调用
        Integer ret = (Integer) pjp.proceed();
        System.out.println("around after advice ...");
        return ret;
    }

    //@AfterReturning：返回后通知，在原始方法执行完毕后运行，且原始方法执行过程中未出现异常现象
//    @AfterReturning("pt2()")
    public void afterReturning() {
        System.out.println("afterReturning advice ...");
    }

    //@AfterThrowing：抛出异常后通知，在原始方法执行过程中出现异常后运行
    @AfterThrowing("pt2()")
    public void afterThrowing() {
        System.out.println("afterThrowing advice ...");
    }
}

AOP总结

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Spring事务

在这里插入图片描述

// 在业务层接口添加spring事务管理
public interface AccountService {
    /**
     * 转账操作
     * @param out 传出方
     * @param in 转入方
     * @param money 金额
     */
    //配置当前接口方法具有事务
    @Transactional
    public void transfer(String out,String in ,Double money) ;
}

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }

    //2.配置事务管理器，mybatis使用的是jdbc事务
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//3.开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}

Spring事务角色

在这里插入图片描述

Spring事务相关配置

在这里插入图片描述

public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out, String in, Double money);
}

在这里插入图片描述

努力成长的小张
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring(一)
weixin_43164309的博客
09-02 176
Spring 简介 分层的Java SE/EE应用 full - stack轻量级开源框架。 核心:IOC(Inverse Of Control 控制反转)和AOP(Aspect Oriented Programming 面向切面编程) 优势 方便解耦，简化开发 AOP编程的支持 声明式事务的支持 方便程序的测试 方便集成各种优秀框架 降低JAVAEE API的使用难度 Java源码经典学习范例 体系结构 1. Data Access/Integration（数据访问／集成） 数据访问/集成层包括
spring—第一个spring程序
weixin_44560620的博客
02-04 155
1.导入依赖 <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.9.RELEASE</version> </dependency> 2.写一个接口和实
Spring的IoC和DI
好好学习
10-27 315
Spring Spring是分层的Java SE/EE应用full-stack轻量级开源框架，以IOC（翻转控制）和AOP（面向切面编程）为内核 提供了展现层SpringMVC和持久层Spring JDBCTemplatey以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多的第三方框架和类库，逐渐成为使用最多的Java EE企业级应用开源框架 Spring优势 1、方便解耦，简化开发 通过Spring提供的IOC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的多度耦合，用
掌握基于SpringBoot框架的程序开发步骤
黑马程序员官方博客
07-19 1667
SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。使用了Spring框架后已经简化了我们的开发。而SpringBoot又是对Spring开发进行简化的，可想而知SpringBoot使用的简单及广泛性。既然SpringBoot是用来简化Spring开发的，那我们就先回顾一下，以SpringMVC创建工程，并在pom.xml配置文件中配置所依赖的坐标编写web3.0的配置类作为web程序，web3.0编写SpringMVC的配置类编写类。...
Spring----（1）Spring的配置
LL的博客
06-25 1296
Spring基础，Spring的配置
spring 学习
08-04
spring学习，通过搭建基本的工程，从中学习spring的原理
spring学习
03-07
spring系统学习，解读spring，源码解读 spring系统学习，解读spring，源码解读 spring系统学习，解读spring，源码解读
spring学习.zip
11-01
本人spring学习笔记资源文档，感兴趣可下载
spring学习资源
10-12
学习spring资源书籍，第三版讲解的很全面，包括springmvc的整合
Spring开发基本坐标
kimyundung的博客
02-03 2876
Spring开发基本坐标 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.1.5.RELEASE</version> </dependency> <dependency> <g
spring dependencies 依赖包 扩展包(part 1/3)
10-20
一共三个包,看清楚了,三个全下,然后解压就行.
spring框架详解
A0G001的博客
09-16 199
切入点: 匹配连接点的式子 @Pointcut("execution(void org.example.dao.UseDao.update())")(2) factory-method “什么方法”factory-bean“在哪里”@Before("sb()") 绑定通知和切入点的关系 sb为定义的切入点。核心容器--数据访问--面向切面--Transactions。@ComponentScan（"路径1","路径2"）
Spring IoC与DI
m0_58169267的博客
07-02 137
Java Spring IoC与DI入门案例
Spring框架学习之Spring-AOP
weixin_50943926的博客
07-05 560
Spring学习之AOP（7.5）
坐标和依赖
RO_wsy的专栏
12-17 1251
坐标和依赖 坐标可以唯一定义一个Maven构件，包括 1.groupId 2.artifactId 3.version 4.packaging 5.classifier 依赖范围 complie test provided runtime system import 依赖范围 编译classpath有效 测试classpath有效 运行时class
（37）Spring入门（Spring框架的基础概念、配置Spring框架需要的依赖、IOC控制反转）
qq_44667083的博客
09-09 172
Spring入门一、耦合二、Spring框架的基础概念1.什么是Spring：2.spring 的优势：3.spring 的体系结构：三、Java的三层架构1.业务层（service）调用持久层（dao），表现层调用业务层（servlet）2.编写工厂类和配置文件三、IOC控制反转1.百度百科给出的概念：2.明确ioc的作用：3.普通三层架构与IOC模式对比五、配置Spring框架需要的依赖1.创建一个maven项目2.在pom.xml文件中建立spring的依赖坐标：3.配置配置文件bean.xml：4.
spring --jia包依赖坐标收集
qq_38288937的博客
09-25 2460
<!--mysql驱动包 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.32</version> ...
Spring 整合 jpa 基于Maven开发的pom文件的坐标依赖内容
name_shanshang的博客
04-30 4975
&lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0....
Spring Context 你真的懂了吗
a1102325298的博客
08-24 1504
今天介绍一下大家常见的一个单词 context 应该怎么去理解，正确的理解它有助于我们学习 spring 以及计算机系统中的其他知识。 1. context 是什么 我们经常在编程中见到 context 这个单词，当然每个人有每个人的理解，它被理解为：上下文、容器等等。我想说的是，context 理解为上下文最为合适。为什么呢？我以一个在计算机系统的例子来解释一下。 在计...
spring 学习笔记
最新发布
04-10
Spring是一个开源的Java框架，用于构建企业级应用程序。它提供了一种轻量级的、非侵入式的开发方式，通过依赖注入和面向切面编程等特性，简化了Java应用程序的开发过程。 以下是关于Spring学习的一些笔记： 1. IoC（控制反转）：Spring通过IoC容器管理对象的创建和依赖关系的注入。通过配置文件或注解，将对象的创建和依赖关系的维护交给Spring容器来管理，降低了组件之间的耦合度。 2. DI（依赖注入）：Spring通过依赖注入将对象之间的依赖关系解耦。通过构造函数、Setter方法或注解，将依赖的对象注入到目标对象中，使得对象之间的关系更加灵活和可维护。 3. AOP（面向切面编程）：Spring提供了AOP的支持，可以将与业务逻辑无关的横切关注点（如日志、事务管理等）从业务逻辑中分离出来，提高了代码的可重用性和可维护性。 4. MVC（模型-视图-控制器）：Spring提供了一个MVC框架，用于构建Web应用程序。通过DispatcherServlet、Controller、ViewResolver等组件，实现了请求的分发和处理，将业务逻辑和视图展示进行了分离。 5. JDBC和ORM支持：Spring提供了对JDBC和ORM框架（如Hibernate、MyBatis）的集成支持，简化了数据库访问的操作，提高了开发效率。 6. 事务管理：Spring提供了对事务的支持，通过声明式事务管理和编程式事务管理，实现了对数据库事务的控制和管理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值