Spring框架学习笔记

最新推荐文章于 2024-06-21 09:54:19 发布
最新推荐文章于 2024-06-21 09:54:19 发布
阅读量426 收藏
点赞数
文章标签： spring 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shmilyche/article/details/124672769
版权

目录

一、Spring简介

1、概念

2、Spring体系结构

3、优点

二、Spring程序开发

1、基于xml开发

①导入 Spring 开发的基本包坐标

②编写 Dao 接口和实现类

③创建 Spring 核心配置文件

④在 Spring 配置文件中配置 UserDaoImpl

⑤使用 Spring 的 API 获得 Bean 实例

2、注解开发

2.1Spring原始注解

2.2代码实现原始注解

2.3 Spring新注解

 2.4 新注解代码实现

三、Spring 的 AOP

1、简介

2、AOP 开发

2.1基于 XML 的 AOP 开发

2.2XML 配置 AOP 详解

2.3基于注解的 AOP 开发

2.4注解配置 AOP 详解

四、Spring的声明式事务控制

1、编程式事务控制相关对象

 2、基于 XML 的声明式事务控制

2.1切点方法的事务参数的配置

3、基于注解的声明式事务控制

一、Spring简介

1、概念

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

Spring提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

2、Spring体系结构

  

3、优点
 

    1、方便解耦，简化开发
    2、AOP 编程的支持
    3、声明式事务的支持
    4、方便程序的测试

二、Spring程序开发

1、基于xml开发

①导入 Spring 开发的基本包坐标

     <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

②编写 Dao 接口和实现类

public interface UserDao {  
    public void save();
}

public class UserDaoImpl implements UserDao {  
        @Override  
        public void save() {
        	System.out.println("UserDao save method running....");
	}
}

③创建 Spring 核心配置文件

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

④在 Spring 配置文件中配置 UserDaoImpl

<bean id="userDao" class="spring.dao.Impl.UserDaoImpl"></bean>

⑤使用 Spring 的 API 获得 Bean 实例

@Test
public void test1(){
		     ApplicationContext applicationContext = new  
             ClassPathXmlApplicationContext("applicationContext.xml");
             UserDao userDao = (UserDao) applicationContext.getBean("userDao");   				         
             userDao.save();
 }

2、注解开发

2.1Spring原始注解

 注意：使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法。

<context:component-scan base-package="指定注解所在包"></context:component-scan>

2.2代码实现原始注解

①使用@Compont或@Repository标识UserDaoImpl需要Spring进行实例化。

//@Component("userDao")
@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
    	System.out.println("save running... ...");
    }
}

②

使用@Compont或@Service标识UserServiceImpl需要Spring进行实例化

使用@Autowired或者@Autowired+@Qulifier或者@Resource进行userDao的注入

//@Component("userService")
@Service("userService")
public class UserServiceImpl implements UserService {
    /*@Autowired
    @Qualifier("userDao")*/
    @Resource(name="userDao")
    private UserDao userDao;
    @Override
    public void save() {       
   	  userDao.save();
    }
}

③使用@Value进行字符串的注入

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Value("注入普通数据")
    private String str;
    @Value("${jdbc.driver}")
    private String driver;
    @Override
    public void save() {
        System.out.println(str);
        System.out.println(driver);
        System.out.println("save running... ...");
    }
}

④使用@Scope标注Bean的范围

//@Scope("prototype")
@Scope("singleton")
public class UserDaoImpl implements UserDao {
   //此处省略代码
}

⑤使用@PostConstruct标注初始化方法，使用@PreDestroy标注销毁方法。

2.3 Spring新注解

 2.4 新注解代码实现

//标志该类是Spring的核心配置类
@Configuration
//配置扫描组件   <context:component-scan base-package="spring.dao"></context:component-scan>
@ComponentScan("spring")
//<import resource = " ">
@Import(DataSourceConfiguration.class)//引入
public class SpringCofiguration {
}


//加载外部的properties文件   <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {
    @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("dataSource")//Spring会将当前方法的返回值以指定的名称存储到Spring容器中
    public DataSource getDataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

测试使用

@RunWith(SpringJUnit4ClassRunner.class)

//加载注解核心类
@ContextConfiguration(classes = {SpringCofiguration.class})
public class SpringJunitTest {

    @Autowired
    private UserService userService;

    @Autowired
    private DataSource dataSource;

    @Test
    public void test1() throws SQLException {
        userService.save();
        System.out.println(dataSource.getConnection());
    }
}

三、Spring 的 AOP

1、简介

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强

优势：减少重复代码，提高开发效率，并且便于维护

2、AOP 开发

2.1基于 XML 的 AOP 开发

①导入 AOP 相关坐标

<!--导入spring的context坐标，context依赖aop-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>
<!-- aspectj的织入 -->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.13</version>
</dependency>

②创建目标接口和目标类（内部有切点）

public interface TargetInterface {
    public void method();
}

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

③创建切面类（内部有增强方法）

public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

④将目标类和切面类的对象创建权交给 spring

<!--配置目标类-->
<bean id="target" class="com.itheima.aop.Target"></bean>
<!--配置切面类-->
<bean id="myAspect" class="com.itheima.aop.MyAspect"></bean>

⑤在 applicationContext.xml 中配置织入关系

<aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
        <!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
        <aop:before method="before" pointcut="execution(public void com.itheima.aop.Target.method())"></aop:before>
    </aop:aspect>
</aop:config>

⑥测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}

2.2XML 配置 AOP 详解

①切点表达式的写法

- 访问修饰符可以省略

- 返回值类型、包名、类名、方法名可以使用星号*  代表任意

- 包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类

- 参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表

execution(public void com.itheima.aop.Target.method())	
execution(void com.itheima.aop.Target.*(..))
execution(* com.itheima.aop.*.*(..))
execution(* com.itheima.aop..*.*(..))
execution(* *..*.*(..))

②通知的类型

<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>

 

③切点表达式的抽取

<aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
        <aop:pointcut id="myPointcut" expression="execution(* com.itheima.aop.*.*(..))"/>
        <aop:before method="before" pointcut-ref="myPointcut"></aop:before>
    </aop:aspect>
</aop:config>

④将目标类和切面类的对象创建权交给 spring

2.3基于注解的 AOP 开发

①创建目标接口和目标类（内部有切点）

public interface TargetInterface {
    public void method();
}

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

②创建切面类（内部有增强方法）

public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

③将目标类和切面类的对象创建权交给 spring

@Component("target")
public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}
@Component("myAspect")
public class MyAspect {
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

④在切面类中使用注解配置织入关系

@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("execution(* com.itheima.aop.*.*(..))")
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

⑤在配置文件中开启组件扫描和 AOP 的自动代理

<!--组件扫描-->
<context:component-scan base-package="com.itheima.aop"/>

<!--aop的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

⑥测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}

2.4注解配置 AOP 详解

①通知的配置语法

②切点表达式的抽取


@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("MyAspect.myPoint()")
    public void before(){
        System.out.println("前置代码增强.....");
    }
    @Pointcut("execution(* com.itheima.aop.*.*(..))")
    public void myPoint(){}
}

四、Spring的声明式事务控制

1、编程式事务控制相关对象

PlatformTransactionManager：

TransactionDefinition：

事务隔离级别：

- ISOLATION_DEFAULT

- ISOLATION_READ_UNCOMMITTED

- ISOLATION_READ_COMMITTED

- ISOLATION_REPEATABLE_READ

- ISOLATION_SERIALIZABLE

 事务传播行为：

  • REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）

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

  • MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常

  • REQUERS_NEW：新建事务，如果当前在事务中，把当前事务挂起。

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

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

  • NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 REQUIRED 类似的操作

  • 超时时间：默认值是-1，没有超时限制。如果有，以秒为单位进行设置

  • 是否只读：建议查询时设置为只读 

TransactionStatus：

 2、基于 XML 的声明式事务控制

①引入tx命名空间

       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd

②配置事务增强

<!--平台事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>

<!--事务增强配置-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

③配置事务 AOP 织入

<!--事务的aop增强-->
<aop:config>
    <aop:pointcut id="myPointcut" expression="execution(* com.itheima.service.impl.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut"></aop:advisor>
</aop:config>

④测试事务控制转账业务代码

@Override
public void transfer(String outMan, String inMan, double money) {
    accountDao.out(outMan,money);
    int i = 1/0;
    accountDao.in(inMan,money);
}

2.1切点方法的事务参数的配置

<tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" timeout="-1" read-only="false"/>
<!--- name：切点方法名称
- isolation:事务的隔离级别
- propogation：事务的传播行为
- timeout：超时时间
- read-only：是否只读-->

3、基于注解的声明式事务控制

①编写 AccoutDao

@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    public void out(String outMan, double money) {
        jdbcTemplate.update("update account set money=money-? where name=?",money,outMan);
    }
    public void in(String inMan, double money) {
        jdbcTemplate.update("update account set money=money+? where name=?",money,inMan);
    }
}

②编写 AccoutService

@Service("accountService")
@Transactional
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;
    @Transactional(isolation = Isolation.READ_COMMITTED,propagation = Propagation.REQUIRED)
    public void transfer(String outMan, String inMan, double money) {
        accountDao.out(outMan,money);
        int i = 1/0;
        accountDao.in(inMan,money);
    }
}

③编写 applicationContext.xml 配置文件

<!—之前省略datsSource、jdbcTemplate、平台事务管理器的配置-->
<!--组件扫描-->
<context:component-scan base-package="com.itheima"/>
<!--事务的注解驱动-->
<tx:annotation-driven/>

秋风&
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Spring总结
zhoumouJava的博客
05-31 675
一、spring是什么？ Spring是一个轻量级的IOC和AOP容器框架 二、为什么要学习Spring？ 1.spring属于低侵入式设计，代码污染极低 2.spring的DI机制将对象之间的依赖关系交由框架处理，减低组件的耦合性 3.spring提供了AOP技术，支持将一些通用任务如安全，事务，日志等进行集中式处理，提高复用 4.spring对于主流的应用框架提供了集成支持 三、Spring核心概念 目前代码出现的问题： 从上图可以看出代码的耦合性较高 解决方案：使用对象时不
Mybatis开发（二）
kior的博客
04-21 321
Mybatis Dao开发方式 5.1Dao需求 根据用户ID查询用户信息 根据用户名查找用户列表 添加用户 5.2原始Dao开发方法 5.2.1使用原有的user映射文件，不需修改 5.2.2新建个UserDao接口 public interface UserDao { /**根据用户ID查询用户信息 * @param id * @return */ User getUser...
Mybatis的Dao层实现原理
kopoo的博客
10-19 2067
1.Mybatis的Dao层实现 1.1 传统开发方式 1.1.1编写UserDao接口 public interface UserDao { List<User> findAll() throws IOException; } 1.1.2.编写UserDaoImpl实现 public class UserDaoImpl implements UserDao { public List<User> findAll() throws IOException
全栈式框架-Spring(上)
qq_52173163的博客
12-05 329
文章目录前言一、Spring概述1.1 spring是什么?1.2 spring有什么优点?1.3 Spring的体系结构二、Spring环境搭建三、IOC四、AOP总结 前言 Spring是分层的JavaSE/EE full-stack 轻量级开源框架，以IOC（Inverse of Control 控制反转）和AOP（Aspect Oriented Programming 面向切面编程）为内核，使用基本的JavaBean来实现程序功能。 一、Spring概述 1.1 spring是什么? sprin
spring框架学习笔记.zip
08-28
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java...
spring框架学习笔记
11-04
Spring框架是Java应用开发中广泛使用的轻量级框架，它以IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）为核心，提供了丰富的功能，包括但不限于组件管理、AOP（Aspect Oriented ...
Spring框架学习笔记文档
10-30
Spring框架的学习笔记，包括了springIOC，spirng注入，springAoP，SpringJdbc模板的使用，Spring声明式事务。
mybatis框架--学习笔记（上）
张维鹏的博客
07-13 1119
使用JDBC操作数据库的问题总结：（1）数据库连接，使用时创建，不使用时立即释放，对数据库进行频繁连接开启和关闭，造成数据库资源浪费，影响数据库性能。设想：使用数据库连接池管理数据库连接。（2）将sql语句硬编译到java代码中，如果sql语句修改，需要重新编译java代码，不利于系统维护。设想：将sql语句配置在xml配置文件中，即使sql变化，不需要对java代码进行重新编译。（3）向preo...
Spring简介
杨钊
07-13 793
Spring是分层的JavaSE/EE full-stack（全栈）轻量级开源框架，以IoC(Inverse of Control控制反转)和AOP(Aspect Oriented Programming 面向切面编程)为内核。轻量级：与EJB对比，依赖资源少，销毁的资源少。全栈：对每一层都提供了解决方案。spring-mvc，spring，jdbcTemplate Spring就是一个大工厂（容器
Spring框架基础知识详解
weixin_44802421的博客
04-20 318
Spring 1.Spring概述 Spring是分层的java SE/EE应用 full-stack 轻量级开源框架,以IOC(Inverse of control)翻转控制和AOP(Aspect Oriented Programming:面向切面编程)为内核. 2.Spring两大核心 IOC AOP 3.Spring发展历程和优势 1.方便解耦便于来发 2.AOP编程的支持 ...
客观面试题--22.浅析Spring？
YyyyyyT的博客
06-13 381
1.Spring 框架概述Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：控制反转）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。控制反转：控制反转(Inversion of Control，英文缩写为IoC)把创建对象的权利交给框架,是框架的重要特征，并非面向对...
《Spring源码深度解析》学习笔记——Spring的整体架构与容器的基本实现
热门推荐
benhuo931115的博客
07-06 12万+
Spring的整体架构Spring框架是一个分层架构，它包含一系列的功能要素，并被分为大约20个模块，如下图所示这些模块被总结为以下几个部分： Core ContainerCore Container(核心容器)包含有Core、Beans、Context和Expression Language模块 Core和Beans模块是框架的基础部分，提供IoC(转控制)和依赖注入特性。这里的基础概念是Bea
Spring基础
andingyi8230的博客
03-25 76
13.1 Spring 概述 Spring框架的主要优势之一是其分层架构，分层架构允许选择使用任一个组件，同时为 Java EE 应用程序开发提供集成的框架。Spring 框架的分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 Bean 的方式，如图7.1所示。 组成Spring 框架的...
springboot中获取某个注解下面的某个方法的方法名，参数值等等详细实例
最新发布
gb4215287的博客
06-21 312
springboot中获取某个注解下面的某个方法的方法名，参数值等等详细实例
spring个人学习笔记
03-04
"这是关于Spring框架的学习笔记，涵盖了Spring的基本概念、优势、体系结构以及快速入门的步骤。笔记旨在帮助读者更方便地学习和理解Spring框架的使用。" Spring框架是Java开发领域中广泛使用的开源框架，它以IoC...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值