Spring笔记

最新推荐文章于 2022-10-12 21:51:01 发布
最新推荐文章于 2022-10-12 21:51:01 发布
阅读量133 收藏
点赞数
文章标签： java 开发工具 测试
原文链接：http://www.cnblogs.com/liandy001/p/11167524.html
版权

开发环境：jdk1.6  Eclipse4.11.0  apache-maven-3.2.5

一、IOC容器

　　1.BeanFactory容器:

这是一个最简单的容器，它主要的功能是为依赖注入 （DI） 提供支持，这个容器接口在 org.springframewor
k.beans.factory.BeanFactor 中被定义。 BeanFactory 和相关的接口，比如，BeanFactoryAware、 Dispo
sableBean、InitializingBean，仍旧保留在 Spring 中，主要目的是向后兼容已经存在的和那些 Spring 整合在
一起的第三方框架。
在 Spring 中，有大量对 BeanFactory 接口的实现。其中，最常被使用的是 XmlBeanFactory 类。这个容器从
一个 XML 文件中读取配置元数据，由这些元数据来生成一个被配置化的系统或者应用。
在资源宝贵的移动设备或者基于 applet 的应用当中， BeanFactory 会被优先选择。否则，一般使用的是 Applic
ationContext，除非你有更好的理由选择 BeanFactory。 
/**  
 * @Title:  HelloWorld.java   
 * @Package cn.com.kamfu   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: liandy    
 * @date:   2019年7月10日 下午11:58:59   
 * @version V1.0 
 */
package cn.com.kamfu;

/**   
 * @ClassName:  HelloWorld   
 * @Description:TODO(这里用一句话描述这个类的作用)   
 * @author: liandy 
 * @date:   2019年7月10日 下午11:58:59   
 *     
 */
public class HelloWorld {
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
    
}
HelloWorld 
<?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-3.0.xsd">
    <bean id="helloWorld" class="cn.com.kamfu.HelloWorld">
        <property name="message" value="Hello World!"/>
    </bean>
</beans>
beans.xml 
package cn.com.kamfu;

import java.io.File;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        // create and configure beans
        File file=new File("D:\\workspace\\Spring\\src\\main\\java\\beans.xml");
        Resource resource=new FileSystemResource(file);
        BeanFactory beanFactory=new XmlBeanFactory(resource);
        HelloWorld helloWorld=beanFactory.getBean("helloWorld",HelloWorld.class);
        System.out.println(helloWorld.getMessage());
 
    }
}
App

 

　　2.ApplicationContext容器:

Application Context 是 spring 中较高级的容器。和 BeanFactory 类似，它可以加载配置文件中定义的 bea
n，将所有的 bean 集中在一起，当有请求的时候分配 bean。 另外，它增加了企业所需要的功能，比如，从属性
文件从解析文本信息和将事件传递给所指定的监听器。这个容器在 org.springframework.context.Application
Context interface 接口中定义。
ApplicationContext 包含 BeanFactory 所有的功能，一般情况下，相对于 BeanFactory，ApplicationConte
xt 会被推荐使用。BeanFactory 仍然可以在轻量级应用中使用，比如移动设备或者基于 applet 的应用程序。
最常被使用的 ApplicationContext 接口实现：
　　• FileSystemXmlApplicationContext：该容器从 XML 文件中加载已被定义的 bean。在这里，你需要提供
给构造器 XML 文件的完整路径
　　• ClassPathXmlApplicationContext：该容器从 XML 文件中加载已被定义的 bean。在这里，你不需要提
供 XML 文件的完整路径，只需正确配置 CLASSPATH 环境变量即可，因为，容器会从 CLASSPATH 中
搜索 bean 配置文件。
　　• WebXmlApplicationContext：该容器会在一个 web 应用程序的范围内加载在 XML 文件中已被定义的 be
an。
　　 
/**  
 * @Title:  HelloWorld.java   
 * @Package cn.com.kamfu   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: liandy    
 * @date:   2019年7月10日 下午11:58:59   
 * @version V1.0 
 */
package cn.com.kamfu;

/**   
 * @ClassName:  HelloWorld   
 * @Description:TODO(这里用一句话描述这个类的作用)   
 * @author: liandy 
 * @date:   2019年7月10日 下午11:58:59   
 *     
 */
public class HelloWorld {
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
    
}
HelloWorld 
<?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-3.0.xsd">
    <bean id="helloWorld" class="cn.com.kamfu.HelloWorld">
        <property name="message" value="Hello World!"/>
    </bean>
</beans>
beans.xml 
package cn.com.kamfu;

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

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        // create and configure beans
        ApplicationContext context=new ClassPathXmlApplicationContext("*.xml");
        HelloWorld helloWorld=context.getBean("helloWorld",HelloWorld.class);
        System.out.println(helloWorld.getMessage());
    }
}
App

 

二、Bean

　　1.定义：用容器提供的配置元数据创建的对象。

 

　　2.bean的属性：

　　

 

　　3.把配置元数据提供给 Spring容器：

　　　　• 基于 XML 的配置文件。
　　　　• 基于注解的配置
　　　　• 基于 Java 的配置
　
三、bean的作用域
　　

 

四、bean的生命周期
　　 
/**  
 * @Title:  HelloWorld.java   
 * @Package cn.com.kamfu   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: liandy    
 * @date:   2019年7月10日 下午11:58:59   
 * @version V1.0 
 */
package cn.com.kamfu;

/**   
 * @ClassName:  HelloWorld   
 * @Description:TODO(这里用一句话描述这个类的作用)   
 * @author: liandy 
 * @date:   2019年7月10日 下午11:58:59   
 *     
 */
public class HelloWorld {
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
    
    public void init(){
        System.out.println("init");
    }
    
    public void destroy() {
        System.out.println("destroy");
    }
}
HelloWorld 
<?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-3.0.xsd">
    <bean id="helloWorld" class="cn.com.kamfu.HelloWorld" init-method="init" destroy-method="destroy">
        <property name="message" value="Hello World!"/>
    </bean>
</beans>
beans.xml 
package cn.com.kamfu;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        // create and configure beans
        AbstractApplicationContext context=new ClassPathXmlApplicationContext("*.xml");
        HelloWorld helloWorld=context.getBean("helloWorld",HelloWorld.class);
        System.out.println(helloWorld.getMessage());
        context.registerShutdownHook();
    }
}
App

 

五、依赖注入

　　1.setter方法注入　　

<!-- 声明accountDao对象并交给spring创建 -->
<bean name="accountDao" class="com.zejian.spring.springIoc.dao.impl.AccountDaoImpl"/>
<!-- 声明accountService对象,交给spring创建 -->
<bean name="accountService" class="com.zejian.spring.springIoc.service.impl.AccountServiceImpl">
      <!-- 通过setter注入accountDao对象,对象注入使用ref-->
      <property name="accountDao" ref="accountDao"/>
</bean>
beans.xml

 

　　2.构造方法注入　　

<bean name="accountDao" class="com.zejian.spring.springIoc.dao.impl.AccountDaoImpl"/>
<!-- 通过构造注入依赖 -->
<bean name="accountService" class="com.zejian.spring.springIoc.service.impl.AccountServiceImpl">
    <!-- 构造方法方式注入accountDao对象,-->
    <constructor-arg  ref="accountDao"/>
</bean>
beans.xml

 

六、基于注解的配置

　　1.@Required：注释应用于 bean 属性的 setter 方法，它表明受影响的 bean 属性在配置时必须放在 XML 配置文
件中，否则容器就会抛出一个 BeanInitializationException 异常。
　　 
/**  
 * @Title:  HelloWorld.java   
 * @Package cn.com.kamfu   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: liandy    
 * @date:   2019年7月10日 下午11:58:59   
 * @version V1.0 
 */
package cn.com.kamfu;

import org.springframework.beans.factory.annotation.Required;

/**   
 * @ClassName:  HelloWorld   
 * @Description:TODO(这里用一句话描述这个类的作用)   
 * @author: liandy 
 * @date:   2019年7月10日 下午11:58:59   
 *     
 */
public class HelloWorld {
    private String message;

    public String getMessage() {
        return message;
    }
    @Required
    public void setMessage(String message) {
        this.message = message;
    }
    
    public void init(){
        System.out.println("init");
    }
    
    public void destroy() {
        System.out.println("destroy");
    }
}
HelloWorld 
<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <context:annotation-config/>
    <bean id="helloWorld" class="cn.com.kamfu.HelloWorld" init-method="init">
<!--         <property name="message" value="Hello World!"/> -->
    </bean>
</beans>
beans.xml 
package cn.com.kamfu;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        // create and configure beans
        AbstractApplicationContext context=new ClassPathXmlApplicationContext("*.xml");
        HelloWorld helloWorld=context.getBean("helloWorld",HelloWorld.class);
        System.out.println(helloWorld.getMessage());
        
    }
}
App 
七月 11, 2019 1:08:11 上午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@2e817b38: startup date [Thu Jul 11 01:08:11 GMT+08:00 2019]; root of context hierarchy
七月 11, 2019 1:08:11 上午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from file [D:\workspace\Spring\target\classes\beans.xml]
七月 11, 2019 1:08:11 上午 org.springframework.context.support.ClassPathXmlApplicationContext refresh
警告: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'helloWorld' defined in file [D:\workspace\Spring\target\classes\beans.xml]: Initialization of bean failed; nested exception is org.springframework.beans.factory.BeanInitializationException: Property 'message' is required for bean 'helloWorld'
Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'helloWorld' defined in file [D:\workspace\Spring\target\classes\beans.xml]: Initialization of bean failed; nested exception is org.springframework.beans.factory.BeanInitializationException: Property 'message' is required for bean 'helloWorld'
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:562)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:481)
	at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:312)
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:230)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:308)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:197)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:756)
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:867)
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:542)
	at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:139)
	at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:83)
	at cn.com.kamfu.App.main(App.java:16)
Caused by: org.springframework.beans.factory.BeanInitializationException: Property 'message' is required for bean 'helloWorld'
	at org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.postProcessPropertyValues(RequiredAnnotationBeanPostProcessor.java:155)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1268)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:551)
	... 11 more
Console输出

 

　　2.@Autowired：一个属性或者任意命名的可能带有多个参数的方法被用于自动连接 bean。　　

/**  
 * @Title:  Shape.java   
 * @Package cn.com.kamfu   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: liandy    
 * @date:   2019年7月11日 上午1:15:28   
 * @version V1.0 
 */
package cn.com.kamfu;

/**   
 * @ClassName:  Shape   
 * @Description:TODO(这里用一句话描述这个类的作用)   
 * @author: liandy 
 * @date:   2019年7月11日 上午1:15:28   
 *     
 */
public class Shape {
    private String size;

    public String getSize() {
        return size;
    }

    public void setSize(String size) {
        this.size = size;
    }
    
}
Shape 
/**  
 * @Title:  Paint.java   
 * @Package cn.com.kamfu   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: liandy    
 * @date:   2019年7月11日 上午1:16:19   
 * @version V1.0 
 */
package cn.com.kamfu;

import org.springframework.beans.factory.annotation.Autowired;

/**   
 * @ClassName:  Paint   
 * @Description:TODO(这里用一句话描述这个类的作用)   
 * @author: liandy 
 * @date:   2019年7月11日 上午1:16:19   
 *     
 */
public class Paint {
    private Shape shape;

    public Shape getShape() {
        return shape;
    }
    @Autowired
    public void setShape(Shape shape) {
        this.shape = shape;
    }
    public void doSomething() {
        if(null!=this.shape) {
            System.out.println("paint:"+this.shape.getClass().getName());
        }
    }
}
Paint 
<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <context:annotation-config/>
    <bean id="paint" class="cn.com.kamfu.Paint">
    </bean>
    <bean id="shape" class="cn.com.kamfu.Shape">
    </bean>
</beans>
beans.xml 
package cn.com.kamfu;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        // create and configure beans
        AbstractApplicationContext context=new ClassPathXmlApplicationContext("*.xml");
        Paint paint=context.getBean("paint",Paint.class);
        paint.doSomething();
        
    }
}
App 
paint:cn.com.kamfu.Shape
Console

　　

　　3.@Resource默认按照ByName自动注入，由J2EE提供，需要导入包javax.annotation.Resource。@Resource有两个重要的属性：name和type，而Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以，如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不制定name也不制定type属性，这时将通过反射机制使用byName自动注入策略。　　

/**  
 * @Title:  Shape.java   
 * @Package cn.com.kamfu   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: liandy    
 * @date:   2019年7月11日 上午1:15:28   
 * @version V1.0 
 */
package cn.com.kamfu;

/**   
 * @ClassName:  Shape   
 * @Description:TODO(这里用一句话描述这个类的作用)   
 * @author: liandy 
 * @date:   2019年7月11日 上午1:15:28   
 *     
 */
public class Shape {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


    
}
Shape 
/**  
 * @Title:  Paint.java   
 * @Package cn.com.kamfu   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: liandy    
 * @date:   2019年7月11日 上午1:16:19   
 * @version V1.0 
 */
package cn.com.kamfu;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;

/**   
 * @ClassName:  Paint   
 * @Description:TODO(这里用一句话描述这个类的作用)   
 * @author: liandy 
 * @date:   2019年7月11日 上午1:16:19   
 *     
 */
public class Paint {
    @Resource(name = "circle")
    private Shape shape;

    public Shape getShape() {
        return shape;
    }

    public void setShape(Shape shape) {
        this.shape = shape;
    }
    public void doSomething() {
        if(null!=this.shape) {
            System.out.println("paint:"+this.shape.getName());
        }
    }
}
Paint 
<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <context:annotation-config/>
    <bean id="paint"  class="cn.com.kamfu.Paint">
    </bean>
    <bean id="shape" name="circle" class="cn.com.kamfu.Shape">
        <property name="name" value="circle"></property>
    </bean>
</beans>
beans.xml 
package cn.com.kamfu;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Hello world!
 *
 */
public class App 
{
    public static void main( String[] args )
    {
        // create and configure beans
        AbstractApplicationContext context=new ClassPathXmlApplicationContext("*.xml");
        Paint paint=context.getBean("paint",Paint.class);
        paint.doSomething();
        
    }
}
App

 

七、基于java的配置

　　@Configuration启动容器+@Bean注册Bean，@Bean下管理bean的生命周期　　

@Configuration
@ComponentScan(basePackages = "com.dxz.demo.configuration")
public class TestConfiguration {
    public TestConfiguration() {
        System.out.println("TestConfiguration容器启动初始化。。。");
    }

    //@Bean注解注册bean,同时可以指定初始化和销毁方法
    @Bean(name="testBean",initMethod="start",destroyMethod="cleanUp")
    @Scope("prototype")
    public TestBean testBean() {
        return new TestBean();
    }
}
TestConfiguration 
public class TestMain {
    public static void main(String[] args) {

        ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);

        TestBean tb = (TestBean) context.getBean("testBean");
        tb.sayHello();
        System.out.println(tb);
        
        TestBean tb2 = (TestBean) context.getBean("testBean");
        tb2.sayHello();
        System.out.println(tb2);
    }
}
TestMain

 

八、AOP

　　1.aop的术语

 

　　2.通知的类型

(1)Before:在目标方法被调用之前做增强处理,@Before只需要指定切入点表达式即可

(2)AfterReturning:在目标方法正常完成后做增强,@AfterReturning除了指定切入点表达式后，还可以指定一个返回值形参名returning,代表目标方法的返回值

(3)AfterThrowing:主要用来处理程序中未处理的异常,@AfterThrowing除了指定切入点表达式后，还可以指定一个throwing的返回值形参名,可以通过该形参名

来访问目标方法中所抛出的异常对象

(4)After:在目标方法完成之后做增强，无论目标方法时候成功完成。@After可以指定一个切入点表达式

(5)Around:环绕通知,在目标方法完成前后做增强处理,环绕通知是最重要的通知类型,像事务,日志等都是环绕通知,注意编程中核心是一个ProceedingJoinPoint

 

　　3.基于注解的aop示例　　

/**  
 * @Title:  Logger.java   
 * @Package cn.com.kamfu   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: liandy    
 * @date:   2019年7月12日 上午1:30:26   
 * @version V1.0 
 */
package cn.com.kamfu;

import org.aspectj.lang.JoinPoint;
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;
import org.springframework.stereotype.Component;

/**   
 * @ClassName:  Logger   
 * @Description:TODO(这里用一句话描述这个类的作用)   
 * @author: liandy 
 * @date:   2019年7月12日 上午1:30:26   
 *     
 */
@Component
@Aspect
public class Logger {
    
    @Pointcut("execution(* cn.com.kamfu.service..*.*(..))")
    public void pointCut(){}
    
    @Before("pointCut()")
    public void doBefore(JoinPoint joinPoint){
        System.out.println("AOP Before Advice...");
    }
    
    @After("pointCut()")
    public void doAfter(JoinPoint joinPoint){
        System.out.println("AOP After Advice...");
    }
    
    @AfterReturning(pointcut="pointCut()",returning="returnVal")
    public void afterReturn(JoinPoint joinPoint,Object returnVal){
        System.out.println("AOP AfterReturning Advice:" + returnVal);
    }
    
    @AfterThrowing(pointcut="pointCut()",throwing="error")
    public void afterThrowing(JoinPoint joinPoint,Throwable error){
        System.out.println("AOP AfterThrowing Advice..." + error);
        System.out.println("AfterThrowing...");
    }
    
    @Around("pointCut()")
    public void around(ProceedingJoinPoint pjp){
        System.out.println("AOP Aronud before...");
        try {
            pjp.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("AOP Aronud after...");
    }
    
}
Logger 
/**  
 * @Title:  UserService.java   
 * @Package cn.com.kamfu   
 * @Description:    TODO(用一句话描述该文件做什么)   
 * @author: liandy    
 * @date:   2019年7月12日 上午1:31:06   
 * @version V1.0 
 */
package cn.com.kamfu.service;

import org.springframework.stereotype.Service;

/**   
 * @ClassName:  UserService   
 * @Description:TODO(这里用一句话描述这个类的作用)   
 * @author: liandy 
 * @date:   2019年7月12日 上午1:31:06   
 *     
 */
@Service
public class UserService {
    
    public void add(){
        System.out.println("UserService add()");
    }
    
    public boolean delete(){
        System.out.println("UserService delete()");
        return true;
    }
    
    public void edit(){
        System.out.println("UserService edit()");
        int i = 5/0;
    }
    
    
}
UserService 
<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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-3.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    <context:component-scan base-package="cn.com.kamfu"/>            
</beans>
beans.xml 
package cn.com.kamfu;


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

import cn.com.kamfu.service.UserService;

/**
 * Hello world!
 *
 */
public class App 
{
    
    public static void main( String[] args )
    {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:beans.xml");
        UserService userService = (UserService) ctx.getBean("userService");
        userService.add();
        
    }
}
App

　　4.基于xml的aop示例

　　……

九、JDBC

　　

十、事务管理

十一、MVC框架

 

转载于:https://www.cnblogs.com/liandy001/p/11167524.html

diaogai3232
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring笔记
04-12
spring笔记spring笔记spring笔记spring笔记spring笔记spring笔记
Spring bean 通过实现 InitializingBean ,DisposableBean 接口实现初始化方法和销毁前操作
安德里亚的成长
03-16 4万+
关于在spring  容器初始化 bean 和销毁前所做的操作定义方式有三种： 第一种：通过@PostConstruct 和 @PreDestroy 方法 实现初始化和销毁bean之前进行的操作 第二种是：通过 在xml中定义init-method 和  destory-method方法 第三种是： 通过bean实现InitializingBean和 DisposableBean接口
黑马程序员SSM_Spring笔记(自用)
qq_62656514的博客
10-12 3458
黑马程序员SSM_Spring笔记(自用)
Spring笔记汇总
studyeglish的博客
05-24 432
学习参考 引言 第一个Spring Spring5.x与日志框架的整合 注入（injection） Set注入详解 构造注入 反转控制 与 依赖注入
【狂神说】——Spring笔记（全）
java小豪的博客
06-28 6933
Spring : 春天 —>给软件行业带来了春天2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。
狂神说最细最全spring笔记
weixin_49356729的博客
11-04 2575
狂神说Spring01：概述及IOC理论推导 狂神说Spring02：快速上手Spring 狂神说Spring03：依赖注入（DI） 狂神说Spring04：自动装配 狂神说Spring05：使用注解开发 狂神说Spring06：静态/动态代理模式 狂神说Spring07：AOP就这么简单 ...
狂神说spring笔记
热门推荐
Frank---7的博客
12-31 6万+
B站 https://www.bilibili.com/video/BV1WE411d7Dv 狂神说Spring01：概述及IOC理论推导 https://mp.weixin.qq.com/s/VM6INdNB_hNfXCMq3UZgTQ 狂神说Spring02：快速上手Spring https://mp.weixin.qq.com/s/Sa39ulmHpNFJ9u48rwCG7A 狂神说Spring03：依赖注入（DI）https://mp.weixin.qq.com/s/Nf-cYENenoZpXqDj
spring笔记整理大全（一）
qq_43154385的博客
12-21 5168
1.spring起源：     早期使用java开发企业应用（企业应用系统，比如：人力资源管理系统、OA办公自动化系统、财务系统 ，所有企业应用的系统总称为ERP）使用EJB（Enterprise java Bean）开发，是sun提供的规范，比如：把javabean分为：Bean（Session Bean），实体Bean（Entity Bean）和消息驱动Bean（MessageDriven...
Spring学习笔记
一条游向寒江的鱼
08-30 373
spring基础学习
尚硅谷Spring笔记
04-11
尚硅谷Spring笔记
韩顺平Spring笔记
04-30
韩顺平Spring教程中的笔记，给大家分享下！ 韩顺平Spring教程中的笔记，给大家分享下！ 韩顺平Spring教程中的笔记，给大家分享下！ 韩顺平Spring教程中的笔记，给大家分享下！
spring 笔记
10-14
spring 初学 笔记 入门提示
Spring笔记.md
12-13
适合听狂神课的人和刚学框架的人
Spring笔记 狂神说
08-17
spring笔记 狂神说
狂神spring笔记.pdf
12-03
狂神的spring讲解资料，已汇总成PDF笔记，并加了章节标签方便阅读
Spring笔记整理.zip
11-22
Spring快速入门,知识收费
狂神spring笔记
最新发布
09-09
狂神的Spring笔记涵盖了以下内容: 1. 概述及IOC理论推导 - 这一部分介绍了Spring框架的概述，以及控制反转（IoC）的理论推导。它解释了Spring框架如何通过IoC容器来管理对象的依赖关系，并提供了一些示例来帮助理解...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值