spring_2

来源：互联网发布：软件评测师真题详解编辑：程序博客网时间：2024/06/05 07:07

2-spring中使用注解代替xml配置_

package cn.itcast.bean;

import javax.annotation.PostConstruct;

import javax.annotation.PreDestroy;

import javax.annotation.Resource;

import javax.xml.ws.RespectBinding;

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;

//将对象注册到dao

//<bean name="user" class="cn.itcast.bean.User" />

//@Component("user")

//@Service("user") // service层

//@Controller("user") // web层

@Repository("user")// dao层

//指定对象的作用范围

@Scope(scopeName="singleton")

public class User {

// 值类型注入

// @Value("tom")

private String name;

@Value("18")

private Integer age;

//引用类型注入

//@Autowired //自动装配

//问题:如果匹配多个类型一致的对象.将无法选择具体注入哪一个对象.

//@Qualifier("car2")//使用@Qualifier注解告诉spring容器自动装配哪个名称的对象

@Resource(name="car")//手动注入,指定注入哪个名称的对象

private Car car;

public Car getCar() {

return car;

}

public void setCar(Car car) {

this.car = car;

}

public String getName() {

return name;

}

@Value("tom")

public void setName(String name) {

this.name = name;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

@PostConstruct //在对象被创建后调用.init-method

public void init(){

System.out.println("我是初始化方法!");

}

@PreDestroy //在销毁之前调用.destory-method

public void destory(){

System.out.println("我是销毁方法!");

}

@Override

public String toString() {

return "User [name=" + name + ", age=" + age + ", car=" + car + "]";

}

03-spring中安装sts插件_

04-spring整合junit测试_

导包4+2+aop+test包

package cn.itcast.b_test;

import javax.annotation.Resource;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import cn.itcast.bean.User;

//帮我们创建容器

@RunWith(SpringJUnit4ClassRunner.class)

//指定创建容器时使用哪个配置文件

@ContextConfiguration("classpath:applicationContext.xml")

public class Demo {

//将名为user的对象注入到u变量中

@Resource(name="user")

private User u;

@Test

public void fun1(){

System.out.println(u);

}

@Test

public void fun2(){

System.out.println(u);

}

@Test

public void fun3(){

System.out.println(u);

}

05-aop思想介绍_

06-aop实现原理-动态代理&CGLib代理_

动态代理代码回顾

package cn.itcast.c_proxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import cn.itcast.service.UserService;

import cn.itcast.service.UserServiceImpl;

//观光代码=>动态代理

public class UserServiceProxyFactory implements InvocationHandler {

public UserServiceProxyFactory(UserService us) {

super();

this.us = us;

}

private UserService us;

public UserService getUserServiceProxy(){

//生成动态代理

UserService usProxy = (UserService) Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader(),

UserServiceImpl.class.getInterfaces(),

this);

//返回

return usProxy;

}

@Override

public Object invoke(Object arg0, Method method, Object[] arg2) throws Throwable {

System.out.println("打开事务!");

Object invoke = method.invoke(us, arg2);

System.out.println("提交事务!");

return invoke;

}

@Test

//动态代理

public void fun1(){

UserService us = new UserServiceImpl();

UserServiceProxyFactory factory = new UserServiceProxyFactory(us);

UserService usProxy = factory.getUserServiceProxy();

usProxy.save();

//代理对象与被代理对象实现了相同的接口

//代理对象与被代理对象没有继承关系

System.out.println(usProxy instanceof UserServiceImpl );//false

}

package cn.itcast.service;

public interface UserService {

void save();

void delete();

void update();

void find();

}

package cn.itcast.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("查找用户!");

}

打开事务!

保存用户!

提交事务!

false

07-手动使用cglib代理(了解)_

package cn.itcast.c_proxy;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import org.springframework.cglib.proxy.Callback;

import org.springframework.cglib.proxy.Enhancer;

import org.springframework.cglib.proxy.MethodInterceptor;

import org.springframework.cglib.proxy.MethodProxy;

import cn.itcast.service.UserService;

import cn.itcast.service.UserServiceImpl;

//观光代码=>cglib代理

public class UserServiceProxyFactory2 implements MethodInterceptor {

public UserService getUserServiceProxy(){

Enhancer en = new Enhancer();//帮我们生成代理对象

en.setSuperclass(UserServiceImpl.class);//设置对谁进行代理

en.setCallback(this);//代理要做什么

UserService us = (UserService) en.create();//创建代理对象

return us;

}

@Override

public Object intercept(Object prxoyobj, Method method, Object[] arg, MethodProxy methodProxy) throws Throwable {

//打开事务

System.out.println("打开事务!");

//调用原有方法

Object returnValue = methodProxy.invokeSuper(prxoyobj, arg);

//提交事务

System.out.println("提交事务!");

return returnValue;

}

测试：

@Test

public void fun2(){

UserServiceProxyFactory2 factory = new UserServiceProxyFactory2();

UserService usProxy = factory.getUserServiceProxy();

usProxy.save();

//判断代理对象是否属于被代理对象类型

//代理对象继承了被代理对象=>true

System.out.println(usProxy instanceof UserServiceImpl );//true

}

08-spring的aop名词解释_

AOP 的开发中的相关术语:

Joinpoint(连接点):目标对象中所有可以增强的方法。所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为spring 只支持方法类型的连接点.

Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint 进行拦截的定义.

Advice(通知/增强):所谓通知是指拦截到Joinpoint 之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)

Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类

动态地添加一些方法或 Field.

Target(目标对象):代理的目标对象

Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.

spring 采用动态代理织入，而 AspectJ采用编译期织入和类装在期织入

Proxy（代理）:一个类被AOP 织入增强后，就产生一个结果代理类

Aspect(切面):是切入点和通知（引介）的结合

09-spring的aop准备工作-导包&定义通知_

10-spring的aop配置-配置将通知织入目标对象_

配置详解:

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

<bean name="userService" class="cn.itcast.service.UserServiceImpl" ></bean>

<bean name="myAdvice" class="cn.itcast.d_springaop.MyAdvice" ></bean>

<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.*(..)

* cn.itcast.service..*ServiceImpl.*(..)

-->

<aop:pointcut expression="execution(* cn.itcast.service.*ServiceImpl.*(..))" id="pc"/>

<aop:aspect ref="myAdvice" >

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

配置详解:

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

<bean name="userService" class="cn.itcast.service.UserServiceImpl" ></bean>

<bean name="myAdvice" class="cn.itcast.d_springaop.MyAdvice" ></bean>

<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.*(..)

* cn.itcast.service..*ServiceImpl.*(..)

-->

<aop:pointcut expression="execution(* cn.itcast.service.*ServiceImpl.*(..))" id="pc"/>

<aop:aspect ref="myAdvice" >

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

11-spring的aop整理_

package cn.itcast.d_springaop;

import org.aspectj.lang.ProceedingJoinPoint;

//通知类

public class MyAdvice {

//前置通知

//|-目标方法运行之前调用

//后置通知(如果出现异常不会调用)

//|-在目标方法运行之后调用

//环绕通知

//|-在目标方法之前和之后都调用

//异常拦截通知

//|-如果出现异常,就会调用

//后置通知(无论是否出现异常都会调用)

//|-在目标方法运行之后调用

//----------------------------------------------------------------

//前置通知

public void before(){

System.out.println("这是前置通知!!");

}

//后置通知

public void afterReturning(){

System.out.println("这是后置通知(如果出现异常不会调用)!!");

}

//环绕通知

public Object around(ProceedingJoinPointpjp) 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("这是后置通知(出现异常也会调用)!!");

}

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

<bean name="userService" class="cn.itcast.service.UserServiceImpl" ></bean>

<bean name="myAdvice" class="cn.itcast.d_springaop.MyAdvice" ></bean>

<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.*(..)

* cn.itcast.service..*ServiceImpl.*(..)

-->

<aop:pointcut expression="execution(* cn.itcast.service.*ServiceImpl.*(..))" id="pc"/>

<aop:aspect ref="myAdvice" >

<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 cn.itcast.d_springaop;

import javax.annotation.Resource;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import cn.itcast.bean.User;

import cn.itcast.service.UserService;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:cn/itcast/d_springaop/applicationContext.xml")

public class Demo {

@Resource(name="userService")

private UserService us;

@Test

public void fun1(){

us.save();

}

这是前置通知!!

这是环绕通知之前的部分!!

保存用户!

这是后置通知(出现异常也会调用)!!

这是环绕通知之后的部分!!

这是后置通知(如果出现异常不会调用)!!

12-spring的aop注解配置(了解)_

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

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

package cn.itcast.e_annotationaop;

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(* cn.itcast.service.*ServiceImpl.*(..))")

public void pc(){}

//前置通知

//指定该方法是前置通知,并制定切入点

@Before("MyAdvice.pc()")

public void before(){

System.out.println("这是前置通知!!");

}

//后置通知

@AfterReturning("execution(* cn.itcast.service.*ServiceImpl.*(..))")

public void afterReturning(){

System.out.println("这是后置通知(如果出现异常不会调用)!!");

}

//环绕通知

@Around("execution(* cn.itcast.service.*ServiceImpl.*(..))")

public Object around(ProceedingJoinPoint pjp) throws Throwable {

System.out.println("这是环绕通知之前的部分!!");

Object proceed = pjp.proceed();//调用目标方法

System.out.println("这是环绕通知之后的部分!!");

return proceed;

}

//异常通知

@AfterThrowing("execution(* cn.itcast.service.*ServiceImpl.*(..))")

public void afterException(){

System.out.println("出事啦!出现异常了!!");

}

//后置通知

@After("execution(* cn.itcast.service.*ServiceImpl.*(..))")

public void after(){

System.out.println("这是后置通知(出现异常也会调用)!!");

}

测试类：

package cn.itcast.e_annotationaop;

import javax.annotation.Resource;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import cn.itcast.bean.User;

import cn.itcast.service.UserService;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:cn/itcast/e_annotationaop/applicationContext.xml")

public class Demo {

@Resource(name="userService")

private UserService us;

@Test

public void fun1(){

us.save();

}

阅读全文

0 0