【学习笔记】Spring02

最新推荐文章于 2024-11-04 20:33:37 发布
最新推荐文章于 2024-11-04 20:33:37 发布
阅读量87 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/u/3943244/blog/2032424
版权

1.使用注解配置spring

（1）导包：4+2+spring-aop-4.2.4.RELEASE.jar

（2）引入aop约束

（3）applicationContext.xml中开启使用注解代理配置文件：

<context:component-scan base-package="com.xing.bean"></context:component-scan><!-component-scan部件扫描->

（4）将对象注册到容器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd ">
<!-- 开启扫描注解 -->
<context:component-scan base-package="com.xing.bean"></context:component-scan>

<bean name="car2" class="com.xing.bean.Car" init-method="init" destroy-method="destroy">
	<property name="name" value="奔驰"></property>
	<property name="color" value="白色"></property>
</bean>

</beans>

（5）代码演示 

package com.xing.bean;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import javax.xml.ws.WebServiceProvider;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

//相当于<bean name="user" class="com.xing.bean.User" scope="" value="" ></bean>
//@Component("user")//将对象注册到容器有四种写法，而下面三种可以可以知道对象的位置信息，而@Component是原始的注解，不能包含对象的位置信息
//@Service("user")---service层
//@Repository("user")-----dao层
@Controller("user")//-----web层

//@Scope(scopeName="prototype")//指定对象的作用范围

public class User {
	
	@Value("tom")
	private String name;
	@Value("18")
	private Integer age;
	
	//给引用类型赋值：两种方式
	//1.@Autowired//按照类型自动装配，缺点：容器内同类对象有多个时无法匹配到是哪一个，需要借助Qualifier
	//@Qualifier("car2")//使用@Qualifier注解告诉spring容器自动装配哪个对象
	
	//2.@Resource name指定对象
	@Resource(name="car2")
	private Car car;
	
	@PostConstruct//在对象被创建后执行-----init-method
	public void init() {
		System.out.println("初始化方法。。。");
	}
	@PreDestroy//在对象被销毁前执行-----destroy-method
	public void destroy() {
		System.out.println("销毁方法。。。");
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	
	@Value("20")
	public void setAge(Integer age) {
		this.age = age;
	}
	public Car getCar() {
		return car;
	}
	public void setCar(Car car) {
		this.car = car;
	}
	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + ", car=" + car + "]";
	}

	
	
	
}

//测试
package com.xing.annotation;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.xing.bean.Car;
import com.xing.bean.User;

public class test {
	
	
	@Test
	public void test1() {
		ClassPathXmlApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		User u=(User) ac.getBean("user");
		User u2=(User) ac.getBean("user");
		System.out.println(u==u2);
		System.out.println(u);
		ac.close();//ClassPathXmlApplicationContext
		
	}
	
	
	@Test
	public void test2() {
		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		Car c=(Car) ac.getBean("car2");
		System.out.println(c);
		
	}

}

2.spring和Junit整合

（1）导包：4+2+spring-aop-4.2.4.RELEASE.jar+spring-test-4.2.4.RELEASE.jar

（2）配置注解及测试代码

package com.xing.annotation;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.xing.bean.User;
//帮助我们创建容器
@RunWith(SpringJUnit4ClassRunner.class)
//指定创建容器时使用哪个配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class test2 {
	//把对象user注入到变量u
	@Resource(name="user")
	private User u;
	@Test
	public void test1() {
		System.out.println(u);
	}
	

}

3.spring中的aop思想介绍

（1）横向覆盖，纵向抽取（AOP思想应用：解决乱码，管理事务，拦截器）

（2）spring实现AOP的原理

动态代理（优先）：被代理对象必须实现接口，才能产生代理对象。如果没有接口，则不能使用动态代理技术（补充：动态代理是指代理对象实现被代理对象的接口，重写一些方法）

cglib代理：没有接口，是第三方的代理技术，可以对任何类生成代理，代理的原理是对目标对象进行继承代理，如果目标对象被final修饰，那么该类无法被cglib代理 

4.spring中的aop演示

aop名词学习：

（1）导包：4（基础包）+2（日志包）+2个spring的aop包（spring-aop-4.2.4.RELEASE.jar+spring-aspects-4.2.4.RELEASE.jar）+2个spring需要的第三方aop包（com.springsource.org.aopalliance联盟-1.0.0.jar+com.springsource.org.aspectj.weaver织入-1.6.8.RELEASE.jar）

（2）准备目标对象

package com.xing.service;
//目标对象
public class UserServiceImpl implements UserService{

	@Override
	public void save() {
		System.out.println("这是保存用户方法");
//		int i=1/0;
	}

	@Override
	public void delete() {
		System.out.println("这是删除用户方法");
		
	}

	@Override
	public void update() {
		System.out.println("这是更新用户方法");
		
	}

	@Override
	public void find() {
		System.out.println("这是查找用户方法");
		
	}

}

（3）准备通知类

package com.xing.springAOP;

import org.aspectj.lang.ProceedingJoinPoint;

//通知类
public class MyAdvice {

// 前置通知
//	|-目标方法运行之前调用
//后置通知(如果出现异常不会调用)
//	|-在目标方法运行之后调用
//环绕通知
//	|-在目标方法之前和之后都调用
//异常拦截通知
//	|-如果出现异常,就会调用
//后置通知(无论是否出现 异常都会调用)
//	|-在目标方法运行之后调用
	
	// 前置通知
	public void before() {
		System.out.println("这是前置通知");
	}
	
	//后置通知(如果出现异常不会调用)
	public void afterReturning() {
		System.out.println("这是后置通知(如果出现异常不会调用)");
	}
	
	//环绕通知
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("这是环绕通知之前的部分");//可用于开启事务
		Object proceed = pjp.proceed();//调用目标方法
		System.out.println("这是环绕通知之后的部分");
		return proceed;
	}
	
	//异常拦截通知
	public void afterException() {
		System.out.println("这是异常拦截通知。。。");
	}
	
	//后置通知
	public void after() {
		System.out.println("这是后置通知(是否出现异常都会调用)");
	}
	
	
	
}

（4）在spring配置文件中将通知织入目标对象中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">

<!-- 准备工作: 导入aop(约束)命名空间 -->
<!-- 1.配置目标对象 -->
	<bean name="userService" class="cn.itcast.service.UserServiceImpl" ></bean>
<!-- 2.配置通知对象 -->
	<bean name="myAdvice" class="cn.itcast.d_springaop.MyAdvice" ></bean>
<!-- 3.配置将通知织入目标对象 -->
	<aop:config>
		<!-- 配置切入点 
			public void cn.itcast.service.UserServiceImpl.save() 
			void cn.itcast.service.UserServiceImpl.save()
			* cn.itcast.service.UserServiceImpl.save()
			* cn.itcast.service.UserServiceImpl.*()
			
			* cn.itcast.service.*ServiceImpl.*(..)-----*：任何类型的；*：后缀名为ServiceImpl的类；*：任何方法；..：参数
			* cn.itcast.service..*ServiceImpl.*(..)-------..：后缀名为ServiceImpl的类以及子包
		-->
		<aop:pointcut expression="execution(* cn.itcast.service.*ServiceImpl.*(..))" id="pc"/>
		<aop:aspect ref="myAdvice" >
			<!-- 指定名为before方法作为前置通知，并指定切点 -->
			<aop:before method="before" pointcut-ref="pc" />
			<!-- 后置 -->
			<aop:after-returning method="afterReturning" pointcut-ref="pc" />
			<!-- 环绕通知 -->
			<aop:around method="around" pointcut-ref="pc" />
			<!-- 异常拦截通知 -->
			<aop:after-throwing method="afterException" pointcut-ref="pc"/>
			<!-- 后置 -->
			<aop:after method="after" pointcut-ref="pc"/>
		</aop:aspect>
	</aop:config>
</beans>
//测试
package com.xing.springAOP;

import javax.annotation.Resource;

import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.xing.service.UserService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:com/xing/springAOP/applicationContext.xml")

public class Test {
	@Resource(name="userService")
	UserService us;//代理对象
	
	@org.junit.Test
	public void test1() {
		us.save();
		System.out.println("---------------------------------");
		us.delete();
		
	}
	

}

 

使用注解的方式把通知织入目标对象：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">

<!-- 准备工作: 导入aop(约束)命名空间 -->
<!-- 1.配置目标对象 -->
<bean name="userService" class="com.xing.service.UserServiceImpl"></bean>
<!-- 2.配置通知对象 -->
<bean name="myAdvice" class="com.xing.springaopAnnotation.MyAdvice"></bean>
<!-- 3.开启使用注解完成织入 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>


</beans>
package com.xing.springaopAnnotation;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

//通知类
//表示这是一个通知类
@Aspect
public class MyAdvice {

// 前置通知
//	|-目标方法运行之前调用
//后置通知(如果出现异常不会调用)
//	|-在目标方法运行之后调用
//环绕通知
//	|-在目标方法之前和之后都调用
//异常拦截通知
//	|-如果出现异常,就会调用
//后置通知(无论是否出现 异常都会调用)
//	|-在目标方法运行之后调用
	
	
	@Pointcut("execution(* com.xing.service.*ServiceImpl.*(..))")
	public void pc() {};
	
	// 前置通知
	@Before("MyAdvice.pc()")//这是简化后的写法，需要有上面的方法才行
	public void before() {
		System.out.println("这是前置通知");
	}
	
	//后置通知(如果出现异常不会调用)
	@AfterReturning("execution(* com.xing.service.*ServiceImpl.*(..))")//这是第一种写法
	public void afterReturning() {
		System.out.println("这是后置通知(如果出现异常不会调用)");
	}
	
	//环绕通知
	@Around("execution(* com.xing.service.*ServiceImpl.*(..))")
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("这是环绕通知之前的部分");//可用于开启事务
		Object proceed = pjp.proceed();//调用目标方法
		System.out.println("这是环绕通知之后的部分");
		return proceed;
	}
	
	//异常拦截通知
	@AfterThrowing("execution(* com.xing.service.*ServiceImpl.*(..))")
	public void afterException() {
		System.out.println("这是异常拦截通知。。。");
	}
	
	//后置通知
	@After("execution(* com.xing.service.*ServiceImpl.*(..))")
	public void after() {
		System.out.println("这是后置通知(是否出现异常都会调用)");
	}
	
	
	
}

//测试
package com.xing.springaopAnnotation;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.xing.service.UserService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:com/xing/springaopAnnotation/applicationContext.xml")
public class TMyest {
	
	@Resource(name="userService")
	private UserService us;
	
	@Test//import org.junit.Test;
	public void test1() {
		us.save();
		
	}
	

}

 

转载于:https://my.oschina.net/u/3943244/blog/2032424

chouya2519
关注
java框架学习笔记spring笔记
12-19
Spring 框架是 Java 开发中的核心框架之一，它为构建企业级应用程序提供了一个全面的编程和配置模型。Spring 的设计理念是“依赖注入”（Dependency Injection，简称 DI）和面向切面编程（Aspect-Oriented ...
springsecurity学习笔记
12-13
在"springsecurity学习笔记"中，你可能会涉及以下主题： - Spring Security的基本配置，包括web安全配置和全局安全配置。 - 如何自定义认证和授权流程，比如实现自定义的AuthenticationProvider和...
Spring学习笔记7-----spring的AOP实现方式3种
weixin_45263852的博客
03-01 180
使用Spring实现AOP 需要导入的依赖包 <!--Aspectj是面向切面编程（AOP）的框架,使用AOP，需要导入这个依赖包--> <dependencies> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId>
2024SpringCloud学习笔记
pineapplegi的博客
07-08 1211
官网开发者模式启动浏览器访问本地端口:8500。
Spring Cloud 学习笔记（1 / 3）
热门推荐
KISS
03-03 21万+
Spring Cloud 学习笔记（2 / 3） Spring Cloud 学习笔记（3 / 3） - - - 01_前言闲聊和课程说明 02_零基础微服务架构理论入门 03_第二季Boot和Cloud版本选型 04_Cloud组件停更说明 05_父工程Project空间新建 06_父工程pom文件 07_复习DependencyManagement和Dependencies 08_支付模块构建(上) 09_支付模块构建(中) 10_支付模块构建(下) 11_热部署Devtool
Spring5学习笔记汇总
分享思想，留下痕迹。
10-31 1万+
大家好，我是Leo哥🫣🫣🫣，前前后后，3个月，断断续续的，终于把孙哥Spring5系列视频看完了，也是陆续把笔记补充上来了。全网最细的Spring系列教程，带你由浅入深的学习Spring，有广度，也有深度。还是那句话，不是你学不会，而是你没找对人。
Spring-尚硅谷-学习笔记
weixin_45581692的博客
10-10 6716
Spring框架是一个轻量级的开源的JavaEE框架。 Spring可以解决企业应用开发的复杂性。 Spring有两个核心部分：IOC和AOP IOC：控制反转，把创建对象的过程交给Spring AOP：面向切面，不修改源代码的情况下进行功能增强 Spring特点 方便解耦，简化开发 AOP编程支持 方便程序测试 方便和其他框架进行整合
Spring学习笔记之spring概述
yjnlovepy的博客
07-30 1340
Spring学习笔记之spring概述（没什么鸟用的文章）
Spring学习笔记
徐小陌的博客
05-27 2261
Spring学习笔记 第一部分：Spring 概述 1.1 Spring 简介 轻量级开源框架 核心是IOC和AOP 使⽤最多的 Java EE 企业应⽤开源框架 1.2 Spring 发展历程 EJB->Expert One-to-One J2EE Design and Development论文->Spring 1.3 Spring 的优势 ⽅便解耦，简化开发 通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进⾏控制，避免硬编码所造成的 过度程序耦合。⽤户也不
学习笔记：尚硅谷Spring6基础篇
D_boj的博客
08-14 3352
本章介绍，Spring6基础使用、Spring的IOC原理、Spring6整合日志框架、容器IOC、面向切面AOP以及依赖注入的方式、自动装配和依赖注入等
Spring 学习笔记
低吟不作语的博客
09-03 1361
Spring 是一个企业级 J2EE 应用开发一站式解决方案，其提供的功能贯穿了项目开发的表现层、业务层和持久化层，同时，Spring 可以和其他应用框架无缝整合轻量：Spring 是一个轻量级的框架，其核心 JAR 包的大小均为 1MB 左右。从系统的资源使用上来说，Spring 也是一个轻量级的框架，在其运行期间只需少量的操作系统资源便能稳定运行。
Spring学习笔记（一）Spring框架入门
weixin_72154059的博客
02-06 1624
1、 我们经常挂在口中的Spring指的是（Spring 框架）它是一个开源框架，有着活跃而庞大的社区。这就是它之所以能长久不衰的原因，Spring支持广泛的应用场景，它可以让Java企业级开发应用程序开更简单。2、Spring是由Rod Johnson组织和开发的一个分层的Java SE/EE一站式（full-stack）轻量级开源框架。它最为核心的理念是IoC（控制反转）和AOP（面向切面编程），其中，IoC是Spring的基础，它支撑着Spring对JavaBean的管理功能；
Springcloud学习笔记.md
07-02
Springcloud学习笔记.md，Springcloud学习笔记.md，Springcloud学习笔记.md，Springcloud学习笔记.md，Springcloud学习笔记.md，Springcloud学习笔记.md，Springcloud学习笔记.md，Springcloud学习笔记.md，Spring...
狂神springcloud学习笔记加代码
03-24
狂神springcloud学习笔记加代码 笔记可以看：https://www.kuangstudy.com/bbs/1374942542566551554#header4 视频链接：https://www.bilibili.com/video/BV1jJ411S7xr
springcloud学习笔记.pdf
03-12
Spring Cloud 学习笔记 本笔记主要介绍了从单体架构到微服务架构的演变过程，以及 Spring Cloud 中的微服务架构搭建。下面是本笔记的详细知识点总结： 一、单体架构 单体架构是指整个系统只有一个工程，打包往往...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 365
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 884
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 926
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
spring循环依赖解决方式
最新发布
qq_36400213的博客
11-04 444
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
Spring 2.5 整合与AOP实践学习笔记
"Spring2.5 学习笔记" 在学习Spring 2.5的过程中，我们需要理解这个版本的核心特性，特别是依赖注入（Dependency Injection, DI）和面向切面编程（Aspect-Oriented Programming, AOP）。以下是对每个章节的详细解释...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值