Spring学习一:IOC(控制反转)和AOP(面向切面)的xml配置和注解方式

Spring框架的作用:为了简化java开发

Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One
J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的

一.IOC(控制反转)

1 构造器注入

(xml配置)

2方法注入

(注解方式)

(xml配置)

二,AOP(面向切面)

注解方式

xml配置

只是使用,那简单,原理后面补上

代码架构

spring-test.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: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-3.0.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-3.0.xsd
                ">
    <!-- 注解支持,为了让我们可以使用注解创建bean -->
	<context:annotation-config />
	<!--设置要扫描的包的位置 -->
    <context:component-scan   base-package="com.eyugame.test" />
	<!-- 支持aop注解 -->
	<aop:aspectj-autoproxy />
	<aop:config >
		<!-- 配置aop触发调用的类是myService也就是下面对应的MyServiceImpl -->
		<aop:aspect id="spect" ref="myAop">
			<!-- 配置调用com.eyugame.test.MyBean的toDo()方法的时候触发aop -->
			<aop:pointcut id="target"
				expression="execution(* com.eyugame.test.MyBean.toDo(..))" />
			<!-- 执行前调用,调用方法为doBefore -->
			<aop:before pointcut-ref="target" method="doBefore()" />
			<!-- 执行后调用,调用方法为doAfter -->
			<aop:after pointcut-ref="target" method="doAfter()" />
			<!-- 返回时调用,调用方法doReturn -->
			<aop:after-returning pointcut-ref="target"
				method="doReturn()" />
			<!-- 抛出异常时候调用,调用方法doReturn -->
			<aop:after-throwing pointcut-ref="target" method="doThrowing()"
				throwing="ex" />
			<!-- 注意 aop:aroup在新版本spring好像失效,坑我 -->
			<!-- <aop:around pointcut-ref="businessService" method="doAround"/> -->
		</aop:aspect>
	</aop:config>
	<bean id="myAop" class="com.eyugame.test.MyAop"></bean>
	<bean id="depedecyBean" class="com.eyugame.test.DependencyBean"></bean>
	<!-- 依赖注入1构造器注入 -->
	<bean id="myBean" class="com.eyugame.test.MyBean">
		<constructor-arg ref="depedecyBean"></constructor-arg>
	</bean>
	<!-- 依赖注入2设值注入 -->
	<bean id="myBean2" class="com.eyugame.test.MyBean2">
		<!-- 名称要跟类里面要注入的类的名字一致 -->
		<property name="iDependency" ref="depedecyBean"></property>
	</bean>
	<!-- 注解Aop -->
	<bean id="myAop2" class="com.eyugame.test.MyAop2"></bean>
</beans>

依赖注入时的接口

package com.eyugame.test;

public interface IDependency {
     void  show();
}

依赖注入的具体类

package com.eyugame.test;

public class DependencyBean implements IDependency {

	public void show() {
		System.out.println("my class name:" + this.getClass());
	}

}

AOP类

package com.eyugame.test;

public class MyAop {

	public MyAop() {
	};

	public void doBefore() {
		System.out.println("执行前调用");
	}

	public void doAfter() {
		System.out.println("执行后调用");
	}

	public void doReturn() {
		System.out.println("结束时候调用");
	}

	public void doThrowing() {
		System.out.println("有异常时候调用");
 }
}
package com.eyugame.test;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
/*注解AOP*/
@Aspect
public class MyAop2 {
	public MyAop2() {
	};

	@Pointcut(value= "execution(* com.eyugame.test.MyBean2.toDo(..))")
	private void init() {

	}

	@Before("execution(* com.eyugame.test.MyBean2.toDo(..))")
	public void doBefore() {
		System.out.println("执行前调用");
	}

	@After("execution(* com.eyugame.test.MyBean2.toDo(..))")
	public void doAfter() {
		System.out.println("执行后调用");
	}

	@AfterReturning("execution(* com.eyugame.test.MyBean2.toDo(..))")
	public void doReturn() {
		System.out.println("结束时候调用");
	}

	@AfterThrowing("execution(* com.eyugame.test.MyBean2.toDo(..))")
	public void doThrowing() {
		System.out.println("有异常时候调用");
	}
}

构造器注入

package com.eyugame.test;

public class MyBean {

     private IDependency iDependency;

     public MyBean(){

     }
     /*依赖注入1:构造器注入*/
     public MyBean(IDependency iDependency){
    	 this.iDependency=iDependency;
     }

     public void toDo() {
    	this.iDependency.show();
     }

}
package com.eyugame.test;
/*方法注入*/
public class MyBean2 {
    
    private IDependency iDependency;

    public MyBean2() {

    }

    public void toDo() {
        this.iDependency.show();
    }

    /* 依赖注入2:之设值注入 */
    public void setiDependency(IDependency iDependency) {
        this.iDependency = iDependency;
    }

}

注解创建的Bean

package com.eyugame.test;

import org.springframework.stereotype.Component;

@Component("myBean3")
public class MyBean3 {

	public void show() {
		System.out.println("my name is MyBean3");
	}
}

测试

import com.eyugame.test.MyBean;
import com.eyugame.test.MyBean2;
import com.eyugame.test.MyBean3;

public class TestSpring {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext("config/spring/spring-test.xml");
		System.out.println("使用构造器注入和配置aop-------------");
		/*依赖注入一:构造器注入|aop测试*/
		MyBean myBean =  context.getBean("myBean",MyBean.class);
		myBean.toDo();
		System.out.println("使用方法注入和注解aop-----------");
		/*依赖注入二:方法注入*/
		MyBean2 myBean2 = context.getBean("myBean2",MyBean2.class);
		myBean2.toDo();
		/*使用注解创建bean*/
		System.out.println("使用注解创建bean-----------");
		MyBean3 myBean3=context.getBean("myBean3",MyBean3.class);
		myBean3.show();
	}
}

依赖的包

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>Test</groupId>
	<artifactId>test2</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>test2</name>
	<url>http://maven.apache.org</url>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<!--各个jar的版本 -->
		<spring.version>3.2.3.RELEASE</spring.version>
		<junit.version>4.11</junit.version>
		<jsonlib.version>2.4</jsonlib.version>
		<shiro.version>1.2.0</shiro.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
			<scope>test</scope>
		</dependency>
		<!-- Spring jars -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.8.5</version>
		</dependency>

		<!-- <dependency> <groupId> org.aspectj</groupId> <artifactId> aspectjweaver</artifactId>
			<version> 1.6.11</version> </dependency> -->
	</dependencies>

</project>

控制台输出

时间: 05-05

Spring学习一:IOC(控制反转)和AOP(面向切面)的xml配置和注解方式的相关文章

Spring基础、IOC(控制反转)、AOP(面向切面编程)、Log4j、注解配置

学习示例代码,包含本篇介绍的Spring常用操作示例和所有所需jar文件下载地址:http://download.csdn.net/detail/daijin888888/9556697 1.什么是Spring,有什么作用 --Spring框架属于一个解决方案框架,可以对其他技术和框架进行整合应用. --*好处是:将程序中的各个组件和框架技术进行解耦,便于日后系统维护,升级和扩展操作. --在SSH中,会将Action,DAO组件都交给Spring框架管理,由Spring框架创建这些对象,建立这

Spring学习之Ioc控制反转(1)

开始之前: 1. 本博文为原创,转载请注明出处 2. 作者非计算机科班出身,如有错误,请多指正 ---------------------------------------------------------------------------开始啦啦啦啦啦------------------------------------------------------------------------------- 从开始接触spring起,听到最多的就是Ioc(控制反转)和AOP(面向切面编程

Spring学习之Ioc控制反转(2)

开始之前: 1. 本博文为原创,转载请注明出处 2. 作者非计算机科班出身,如有错误,请多指正 ---------------------------------------------------------------------------开始啦啦啦啦啦------------------------------------------------------------------------------- 上一篇博文简单的演示了如何用Spring框架创建bean,注入bean,并使用到

Spring框架使用(控制反转,依赖注入,面向切面AOP)

参见:http://blog.csdn.net/fei641327936/article/details/52015121 Mybatis: 实现IOC的轻量级的一个Bean的容器 Inversion of control 控制反转:由容器控制程序之间的关系,不是程序代码操作 Depend Inject 依赖注入 Aspect oriented programming 面向切面编程 Spring能帮助我们根据配置文件创建及组装对象之间的依赖关系: Spring面向切面编程能帮助我们无耦合的实现日

Spring框架中IoC(控制反转)的原理

一.IoC的基础知识以及原理: 1.IoC理论的背景:在采用面向对象方法设计的软件系统中,底层实现都是由N个对象组成的,所有的对象通过彼此的合作,最终实现系统的业务逻辑.即软件系统中对象之间的耦合,对象A和对象B之间有关联,对象B又和对象C有依赖关系,这样对象和对象之间有着复杂的依赖关系,所以才有了控制反转这个理论. 2.什么是控制反转(IoC): (1).IoC是Inversion of Control的缩写,有的翻译成"控制反转",还有翻译成为"控制反向"或者&

Spring中的Ioc控制反转与DI注入

Spring的控制反转 1.spring的介绍 spring是一款很受欢迎的java开源框架,核心全程围绕着BeanFactory展开,构成如下图. 2.IOC控制反转 2.1定义:把对象创建交给spring管理,不用new的方法,也不用工厂模式 2.2原理:1.xml配置文件,2.dom4j解析xml,3.工厂设计模式,4.反射 2.3使用:1.配置文件方式,2.注解方式 3.IOC注入bean管理  3.1.1 xml配置方式 1.就是xml配置文件中的spring创建对象的方式,也就是be

Spring中的IoC(控制反转)具体是什么东西

IOC:inverse of Control: 控制反转. 意思是程序中的之间的关系,不用代码控制,而完全是由容器来控制.在运行阶段,容器会根据配置信息直接把他们的关系注入到组件中.同样,这也是 依赖注入的含义.依赖注入和控制反转其实是一个概念.只不过强调的不同而已,依赖注入强调关系的注入是由容器在运行时完成,而控制反转强调关系是由容器控制.其实本质是一样的. 贴一段代码 /** * 学校类 */ public class School { private String name; public

Spring 学习 2- IOC原理 控制反转/依赖注入

控制反转/依赖注入 最近,买了本spring入门书:spring In Action .大致浏览了下感觉还不错.就是入门了点.Manning的书还是不错的,我虽然不像哪些只看Manning书的人那样专注于Manning,但怀着崇敬的心情和激情通览了一遍.又一次接受了IOC .DI.AOP等Spring核心概念. 先就IOC和DI谈一点我的看法. IOC(DI):其实这个Spring架构核心的概念没有这么复杂,更不像有些书上描述的那样晦涩.Java程序员都知道:java程序中的每个业务逻辑至少需要

spring学习总结一----控制反转与依赖注入

spring作为java EE中使用最为广泛的框架,它的设计体现了很多设计模式中经典的原则和思想,所以,该框架的各种实现方法非常值得我们去研究,下面先对spring中最为重要的思想之一----控制反转(依赖注入)进行简单的总结. 一.控制反转与依赖注入的概念 在学习spring框架的时候,我们习惯性地将控制反转和依赖注入放在一起,其实,两者体现的思想原则都是差不多的,只不过控制反转是一种更广泛的程序操作理念,而依赖注入是一种更为具体的实现方法,总的来说,控制反转可以依靠依赖注入来实现. 1.控制