Spring框架学习笔记

最新推荐文章于 2024-02-06 21:15:15 发布
最新推荐文章于 2024-02-06 21:15:15 发布
阅读量139 收藏
点赞数
分类专栏： JavaWeb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43708069/article/details/104505210
版权
搭建spring环境
1.导入jar包(5+1个)(IDEA可以直接创建spring项目)

​    spring-aop.jar //开发aop

​    spring-beans.jar //处理Bean

​    spring-context.jar //处理spring上下文

​    spring-core.jar //核心jar

​    spring-expression.jar //spring表达式 EL JTSL

​    commons-logging.jar //日志

2.编写配置文件applicationContext.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"
       	xmlns:c="http://www.springframework.org/schema/c" 						  				xmlns:util="http://www.springframework.org/schema/util"
     	xmlns:p="http://www.springframework.org/schema/p" 						  xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:aop="http://www.springframework.org/schema/aop" 		xmlns:tool="http://www.springframework.org/schema/tool"
       	xmlns:cache="http://www.springframework.org/schema/cache" 			xmlns:jee="http://www.springframework.org/schema/jee"
      	 xmlns:lang="http://www.springframework.org/schema/lang" 	xmlns:task="http://www.springframework.org/schema/task"
      	 xsi:schemaLocation="http://www.springframework.org/schema/beans 			http://www.springframework.org/schema/beans/spring-beans.xsd
     			http://www.springframework.org/schema/util 									http://www.springframework.org/schema/util/spring-util.xsd
     	 		http://www.springframework.org/schema/context 							http://www.springframework.org/schema/context/spring-context.xsd
      	 		http://www.springframework.org/schema/aop 			http://www.springframework.org/schema/aop/spring-aop.xsd
	      	 	http://www.springframework.org/schema/tool 			http://www.springframework.org/schema/tool/spring-tool.xsd
       	 		http://www.springframework.org/schema/cache 			http://www.springframework.org/schema/cache/spring-cache.xsd
       			http://www.springframework.org/schema/jee 			http://www.springframework.org/schema/jee/spring-jee.xsd
       			http://www.springframework.org/schema/lang 			http://www.springframework.org/schema/lang/spring-lang.xsd
        			http://www.springframework.org/schema/task 			http://www.springframework.org/schema/task/spring-task.xsd">
       	 
</beans>

事务版

<?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:c="http://www.springframework.org/schema/c" xmlns:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tool="http://www.springframework.org/schema/tool"
       xmlns:cache="http://www.springframework.org/schema/cache" xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:lang="http://www.springframework.org/schema/lang" xmlns:task="http://www.springframework.org/schema/task"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tool http://www.springframework.org/schema/tool/spring-tool.xsd
        http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
        http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">
        
</beans>



依赖注入

​ set方法赋值

​    用<property>标签

​       如果是简单类型（8个基本+String）,标签内用value（value=“属性值”，属性值类型默认为String类型）

​       如果是对象类型，标签内用ref=“需要引用的id值”，实现对象与对象之间的依赖关系

​ 构造方法赋值

​    用<constructor-arg>标签

​       默认会按照构造方法属性顺序赋值，也可用name指定参数名、index指定索引位置、type指定参数类型

​       如果是简单类型（8个基本+String）,标签内用value

​       如果是对象类型，标签内用ref=“需要引用的id值”，实现对象与对象之间的依赖关系

​ p命名空间赋值

​    引入p命名空间

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

​    简单类型： p:属性名=“属性值”

​    引用类型：p:属性名-ref=“引用的id”

​ 自动装配（只适用于ref类型）

<bean id="student" class="cn.test.entity.Student" autowire="byName|byType|constructor"/>

​    byName：自动寻找：其他bean的id值=该Student类的属性名

​    byType ：其他bean的类型(class) 是否与 该Student类的ref属性类型一致

​    constructor:其他bean的类型(class)是否与该Course类的构造方法参数的类型一致

​    自动装配虽然可以减少代码量，但是会降低程序的可读性， 使用时需要谨慎

​ 使用注解定义bean

​    通过注解的形式 将bean以及相应的属性值 放入ioc容器

​     步骤：

​       a.在相应的java文件添加注解

​          @Component细化：

​             dao层注解：@Repository

​             service层注解：@Service

​             控制层注解：@Controller

​       b.在applicationContext.xml中添加扫描器

	<context:component-scan base-package="cn.test.dao"/>



使用注解实现事务

1.导入jar包

​    spring-tx.jar

​    ojbdc.jar

​    commons-dbcp.jar 连接池使用到数据源

​    commons-pool.jar 连接池

​    spring-jdbc.jar

​    aopalliance.jar

2.在applicationContext.xml中配置

    <!--  配置注解扫描器  -->
    <context:component-scan base-package="cn.test.daoImpl"/>

    <!-- 配置数据库相关 -->
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring"/>
        <property name="username" value="root"/>
        <property name="password" value="qiuqiuqiu"/>
    </bean>

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

    <!--  增加对事务的支持  -->
    <tx:annotation-driven transaction-manager="txManager"/>

3.使用

   在需要 成为事务的的方法 前加注解@Transactional



AOP切面编程

​ 一个普通类 → 由特定功能的类四种方法：

​    a.继承类

​    b.实现接口（类 → 通知 通过实现接口）

​    c.注解

​    d.配置

前置通知

​    实现步骤：

​       a.导入jar包（aopalliance.jar、aspectjweaver.jar）

​       b.编写业务类、业务方法和通知类（前置通知类需实现MethodBeforeAdvice接口）

​       c.配置

​          将业务类、通知 纳入springIOC容器

​          定义切入点、定义通知类（另一端）， 通过pointcut-ref将两端连起来

 	 <!-- 配置前置通知 -->
    
    <!--  目标方法addStudent()  -->
    <bean id="studentSerice" class="cn.test.serviceImpl.StudentServiceImpl">
        <property name="studentDao" ref="studentDao"/>
    </bean>
    
    <!--  前置通知类  -->
    <bean id="logBefore" class="cn.test.aop.LogBefore">
    </bean>
    
     <!-- 将方法所在类和通知关联 -->
    <aop:config>
       <!-- 配置切入点（在哪里执行通知） -->
        <aop:pointcut expression="execution(public * cn.test.service.StudentService..*(..))" id="pointCut"/>
       <!--相当于 连结切入点 和 切面 的线-->
	<aop:advisor advice-ref="logBefore" pointcut-ref="pointCut"/>
    </aop:config>

后置通知

​    与前置通知类似，后置通知类实现MethodBeforeAdvice接口

异常通知

​    需实现ThrowsAdvice接口，看源码发现该接口虽然为空接口，但要实现

​       public void afterThrowing([Method, args, target], ThrowableSubclass)方法

   两种实现：

​       a.public void afterThrowing(Method, args, target, ThrowableSubclass)

​       b.public void afterThrowing(ThrowableSubclass)

环绕通知

​    在目标方法的前后、异常发生时、最终等各个地方都可以进行的通知，最强大的一个通知；可以获取目标方法的全部控制权

​    在使用环绕通知时，目标方法的一切信息都可以通过invocation参数获取

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object result = null;
        try{
            System.out.println("用环绕通知实现的 前置通知");

            //执行目标方法(该代码前的代码为前置通知, 后面的代码为后置通知)
            result = invocation.proceed();

            System.out.print("用环绕通知实现的 后置通知: 目标对象："+invocation.getThis()+" 方法名："+invocation.getMethod());
            System.out.println(" 方法个数参数："+invocation.getArguments().length+" 方法返回值："+result);

        }catch (Exception e){
            //catch里的代码为异常通知
            System.out.println("用环绕通知实现的 异常通知");
        }

        return result;
    }

用注解实现通知

​    a.导入jar包（aopalliance.jar、aspectjweaver.jar）

​    b.编写业务类、业务方法和通知类

​    c.配置

​       将业务类、通知 纳入springIOC容器（注解形式实现aop时，通知方法参数列表不能乱写）

@Component("logAnnotation")//用注解方式将通知纳入springIOC容器
@Aspect//此类是一个通知
public class LogAspectAnnotation {

    //前置通知
    @Before("execution(public * cn.test.service.StudentService..*(..)))")//属性：定义切点
    public void myBefore(JoinPoint joinPoint){
        System.out.println("注解形式 前置通知: 目标对象:"+joinPoint.getTarget()+" 方法："+joinPoint.getSignature().getName()+" 参数列表："+ Arrays.toString(joinPoint.getArgs()));
    }

    //后置通知
    @AfterReturning(pointcut = "execution(public * cn.test.service.StudentService..*(..)))" , returning = "returningValue")
    public void myAfter(JoinPoint joinPoint, Object returningValue){
        System.out.println("注解形式 后置通知: 目标对象:"+joinPoint.getTarget()+" 方法："+joinPoint.getSignature().getName()+" 参数列表："+ Arrays.toString(joinPoint.getArgs())+" 返回值："+returningValue);
    }

    
    //环绕通知
    @Around("execution(public * cn.test.service.StudentService..*(..)))")
    public void myArround(ProceedingJoinPoint pj){
        //方法执行前 前置通知
        System.out.println("注解形式 环绕通知 前置通知");
        try {
            //方法执行时
            pj.proceed();

            //方法执行后  后置通知
            System.out.println("注解形式 环绕通知 后置通知");
        }catch (Throwable throwable) {
            //发生异常时 异常通知
            System.out.println("注解形式 环绕通知 异常通知");
            throwable.printStackTrace();
        } finally {
            //最终通知
            System.out.println("注解形式 环绕通知 最终通知");
        }
    }


    //异常通知
    @AfterThrowing(pointcut = "execution(public * cn.test.service.StudentService..*(..)))", throwing = "e")
    public void myThrowing(JoinPoint jp, NullPointerException e){
        System.out.println("注解形式 异常通知 :"+ e);
    }

    //最终通知
    @After("execution(public * cn.test.service.StudentService..*(..)))")
    public void myAfter(){
        System.out.println("最终通知");
    }
}

​    在applicationContext.xml中开启注解对AOP的支持、配置注解扫描器

​    扫描器会将指定包中的@Componet、@Service、@Respository、@Controller修饰的类产生的对象增加到IOC容器中（注意扫描器只管这四种）

   <!--  配置注解扫描器  -->
   <context:component-scan base-package="cn.test.daoImpl, cn.test.aop"/>
   
   <!--开启注解对AOP支持-->
   <aop:aspectj-autoproxy/>

通过配置实现通知

​    基于Schema配置

​    类似于实现接口的方式，但不需要继承接口，而是通过配置

applicationContext.xml:

<!--  目标方法addStudent()  -->
<bean id="studentSerice" class="cn.test.serviceImpl.StudentServiceImpl">
	<property name="studentDao" ref="studentDao"/>
</bean>

<!-- 将通知导入IOC容器 -->
<bean id="logArroundSchema" class="cn.test.aop.LogArroundSchema"/>

<!-- 将方法所在类和通知关联 -->
<aop:config>
    <aop:pointcut id="logSchema"  expression="execution(public * addStudent(..))"/>
    <aop:aspect ref="logArroundSchema">
    	<aop:around method="invoke" pointcut-ref="logSchema"/>
    </aop:aspect>
</aop:config>

LogArroundSchema.java:

public class LogArroundSchema {
    public Object invoke(ProceedingJoinPoint invocation) throws Throwable {
        Object result = null;
        try{
            System.out.println("【配置形式】用环绕通知实现的 前置通知");

            //执行目标方法(该代码前的代码为前置通知, 后面的代码为后置通知)
            result = invocation.proceed() ;

            System.out.print("【配置形式】用环绕通知实现的 后置通知: 目标对象："+invocation.getThis()+" 方法名："+invocation.getSignature().getName());
            System.out.println(" 方法个数参数："+invocation.getArgs().length+" 方法返回值："+result);

        }catch (Exception e){
            //catch里的代码为异常通知
            System.out.println("【配置形式】用环绕通知实现的 异常通知"+e);
            e.printStackTrace();
        }

        return result;
    }
}



Spring开发Web项目

在web.xml中配置web启动时自动实例化IOC容器（需导入spring-web.jar）

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:applicationContext.xml</param-value>
    </context-param>

    <!--
        配置spring-web.jar提供的监听器，此监听器可以在服务器启动时初始化IOC容器
        初始化IOC容器(applicationContext.xml):
            1.告诉监听器此容器的位置context-para(在上面)
            2.约定放在WEB-INF里并且文件名必须叫applicationContext.xml
     -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

拆分Spring配置文件

拆分方式

​    a.三层结构

​       UI（html/css/jsp、Servlet） applicationContext-Controller.xml

​       Service applicationContext-Service.xml

​       Dao applicationContext-Dao.xml

​       公共部分（例数据库：applicationContext-DB.xml）

​    b.功能拆分

​       学生相关配置 applicationContext-Student.xml

​       班级相关配置 applicationContext-Class.xml

合并配置

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>
		classpath:applicationContext.xml,
		classpath:applicationContext-*.xml
	</param-value>
</context-param>
替这位空想家惊讶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring aop配置
flyinglzd2013的专栏
09-18 1097
1、我理解的Spring AOP  AOP其实就是划分出来了一个切面，然后在这个切面里面进行了一些增强,最后产生一个增加了新功能的代理对象，注意，是代理对象，这是Spring AOP实现的基础。这个对象只不过比原始对象（Bean）多了一些功能而已，比如Bean预处理，Bean后处理，异常处理等。  2、简单的Demo理解Spring AOP  首先定义一个AOP代理工厂AOPProx
日志拦截AOP，当执行抛异常时@AfterThrowing执行了没效果
热门推荐
张顶飞的博客
05-05 2万+
使用Spring的AOP进行日志记录，对应的代码为 package cn.tiansu.eway.logAop; import java.lang.reflect.Method; import java.util.HashMap; import java.util.Map; import javax.inject.Inject; import org.apache.shiro.Securi
@AfterThrowing(处理未处理的java异常)
IT_COOKIE_SAM的博客
02-21 1万+
正如题目所说,@afterthrowing是对于java异常的处理,但是你会说Java本身也有异常机制啊 error throwable exception runtimexception 并且也有一系列的自定义异常  也有对于异常的描述   譬如:e 是异常对象,我们可以使用e.getmessage()方法对异常进行描述.但是@afterThrowing是aop形式的异常描述,是在主类文件外部来
Spring4之AOP注解配置详解
dns007
08-08 1万+
启动AOP配置   要在 Spring 应用中使用 AspectJ 注解，需要如下支持： 1. 在 classpath 下包含 AspectJ 类库：aopalliance.jar、aspectj.weaver.jar 和 spring-aspects.jar 2. 将 aop Schema 添加到 Bean 配置文件  根元素中。 3. 在 Bean 配置文件中定义
Spring笔记
qq_49306008的博客
01-06 1962
Spring笔记 一、Spring概述 1.1、Spring框架是什么 ​ Spring框架是可以在JavaSE/EE中使用的轻量级开源框架，目的是为了解决企业应用开发的复杂性而创建的，Spring的核心是控制反转（IoC）和面向切面编程（AOP）。 ​ Spring的主要作用就是为代码 “解耦”，降低代码间的耦合度，就是让对象和对象（模块和模块）之间的关系不是使用代码关联，而是通过配置来说明。Spring根据代码的功能特点，使用IoC降低业务对象之间的耦合度。IoC使得主业务在相互调用过程中，不用再自
spring框架学习笔记.zip
08-28
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java...
Spring框架学习笔记文档
10-30
本篇笔记将深入探讨Spring框架的主要组件和概念，旨在帮助开发者全面理解并熟练运用Spring。 1. **Spring IOC**：控制反转是Spring的核心特性，它改变了传统Java应用中对象创建和依赖关系的管理方式。在Spring中，...
马士兵老师spring框架学习笔记
02-28
马士兵老师是知名的Java教育专家，他的Spring框架学习笔记深入浅出，对于初学者和进阶者来说都是一份宝贵的资源。这份笔记涵盖了Spring的核心概念、配置、AOP（面向切面编程）、DI（依赖注入）等关键知识点。 1. **...
Spring总结
zhoumouJava的博客
05-31 686
一、spring是什么？ Spring是一个轻量级的IOC和AOP容器框架 二、为什么要学习Spring？ 1.spring属于低侵入式设计，代码污染极低 2.spring的DI机制将对象之间的依赖关系交由框架处理，减低组件的耦合性 3.spring提供了AOP技术，支持将一些通用任务如安全，事务，日志等进行集中式处理，提高复用 4.spring对于主流的应用框架提供了集成支持 三、Spring核心概念 目前代码出现的问题： 从上图可以看出代码的耦合性较高 解决方案：使用对象时不
传智博客Spring框架2016版笔记资料
11-19
传智博客 Spring框架 2016版 笔记 资料 day01~day04 PDF+WORD文档
spring框架整体学习笔记
08-05
spring框架整体知识点整理，代码样例
spring框架学习笔记
11-04
这是学习spring时整理的学习笔记，里面都是spring框架的一些基础知识和核心技术。
spring框架--全面详解（学习笔记）
swy2560666141的博客
02-26 9924
由 Spring IoC 容器管理的对象称为 Bean，Bean 根据 Spring 配置文件中的信息创建。可以把 Spring IoC 容器看作是一个大工厂，Bean 相当于工厂的产品，如果希望这个大工厂生产和管理 Bean，则需要告诉容器需要哪些 Bean，以及需要哪种方式装配 Bean。Spring 配置文件支持两种格式，即 XML 文件格式和 Properties 文件格式。
Spring学习笔记（一）Spring框架入门
最新发布
weixin_72154059的博客
02-06 1525
1、 我们经常挂在口中的Spring指的是（Spring 框架）它是一个开源框架，有着活跃而庞大的社区。这就是它之所以能长久不衰的原因，Spring支持广泛的应用场景，它可以让Java企业级开发应用程序开更简单。2、Spring是由Rod Johnson组织和开发的一个分层的Java SE/EE一站式（full-stack）轻量级开源框架。它最为核心的理念是IoC（控制反转）和AOP（面向切面编程），其中，IoC是Spring的基础，它支撑着Spring对JavaBean的管理功能；
Spring框架笔记
weixin_51356824的博客
04-09 1059
Spring详解
Spring框架学习笔记：从IoC到AOP
Spring框架学习笔记 Spring框架是Java应用程序开发中最流行的框架之一，它提供了一系列的功能来帮助开发者快速构建企业级应用程序。 Spring框架的核心概念包括IoC（Inverse of Control）和AOP（Aspect-Oriented ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值