SPRING--Spring中IOC(反转控制) 和 AOP(面向方面编程)

原创 2012年10月11日 10:54:12
一、IOC
基本注入和集合注入


实体类Bean--配置文件(applicationContext)--测试类(Test)

1.1 实体Bean:属性+getter()方法+setter()方法
public class MyBean {
private String url;
private String name;
private String pwd;
private int age;
private List list;
private Set set;
private Map map;
private Properties prop;
public String getUrl() {
 return url;
}
public void setUrl(String url) {
 this.url = url;
}

//----此处省略其他属性的getter()和setter()方法----

1.2 Spring配置文件: 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"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 <bean id="myBean" class="jorton.MyIoc.MyBean">
   <property name="url">
     <value>www.163.com</value>
   </property>
   <property name="name">
     <value>xuliang</value>
   </property>
   <property name="pwd" value="123456"></property>
   <property name="age">
     <value>25</value>
   </property>
   <property name="list">
     <list>
       <value>ibm</value>
       <value>sun</value>
       <value>oracle</value>
     </list>
   </property>
   <property name="set">
     <set>
       <value>music</value>
       <value>sleeping</value>
       <value>sports</value>
     </set>
   </property>
   <property name="map">
     <map>
       <entry key="mySister" value="yanmei"></entry>
       <entry key="myMother" value="wenxian"></entry>
       <entry key="myFather" value="guoxian"></entry>
     </map>
   </property>
 </bean>
</beans>



1.3 Test类:用于通过 ApplicationContext的方法getBean(..)获取myBean的属性值。
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
 public static void main(String[] args) {
   ApplicationContext ctx = new ClassPathXmlApplicationContext(
       "jorton/MyIoc/applicationContext.xml");
   MyBean myBean = (MyBean) ctx.getBean("myBean");
   System.out.println(myBean.getUrl());
   System.out.println(myBean.getName());
   System.out.println(myBean.getPwd());
   System.out.println(myBean.getAge());
   System.out.println(myBean.getList());
   System.out.println(myBean.getSet());
   System.out.println(myBean.getMap());
   System.out.println();
 }
}



---------------------------运行结果-----------------------------
www.163.com
xuliang
123456
25
[ibm, sun, oracle]
[music, sleeping, sports]
{mySister=yanmei, myMother=wenxian, myFather=guoxian}
---------------------------------------------------------------------

二、AOP(面向方面编程)
Aspect Oriented Programming
目标对象(TargetObject)和切面(TransactionAspect)--配置文件(applicationContext)--测试类(Test)

2.1 目标对象类(TargetObject)
public class TargetObject {
 public void add(){
   System.out.println("我添加了一些东西。。。");
 }
 public void update(){
 System.out.println("我更新了一些东西。。。");
 }
}



2.2 切面(TransactionAspect)
import org.aspectj.lang.ProceedingJoinPoint;

public class TransactionAspect {
 public void beforeMethod() {
   System.out.println("对象方法开始之前的操作。。。");
 }
 public void afterMethod() {
   System.out.println("对象方法之后的操作。。。");
 }
 public Object roundMethod(ProceedingJoinPoint pjp) throws Throwable {
   System.out.println("环绕方法上。。。");
   Object object = pjp.proceed();
   System.out.println("环绕方法下。。。。");
   return object;
 }
 public void throwMethod() {
   new RuntimeException();
   System.out.println("异常出现执行的操作。。。");
 }
 public void afterReturningMethod() {
   System.out.println("---afterReturning--的操作。。。");
 }
}



2.3 配置文件(applicationContext)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:aop="http://www.springframework.org/schema/aop" 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
 http://www.springframework.org/schema/aop
 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
 <!-- 目标对象 -->
 <bean id="targetObject" class="tarena.myAop.TargetObject"></bean>
 <!-- 切面对象 -->
 <bean id="transactionAspect" class="tarena.myAop.TransactionAspect"></bean>
 <aop:config>
 <!-- 定义切面aspect-->
   <aop:aspect id="myAspect" ref="transactionAspect">
 <!--切入点pointcut-->
     <aop:pointcut id="transcut" expression="execution(* jorton.myAop.*.* (..))" />
 <!--定义通知--前置通知、后置通知、最终通知、环绕通知>
     <aop:before pointcut-ref="transcut" method="beforeMethod" />
     <aop:after pointcut-ref="transcut" method="afterMethod" />
     <aop:after-returning pointcut-ref="transcut"
       method="afterReturningMethod" />
     <aop:around pointcut-ref="transcut" method="roundMethod" />
   </aop:aspect>
 </aop:config>
</beans>

 

2.4 测试类(Test)

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AOPTest {
 public static void main(String[] args){
   ApplicationContext ctx=new ClassPathXmlApplicationContext(
       "tarena/myAop/applicationContext.xml");
   TargetObject targetObject= (TargetObject) ctx.getBean("targetObject");
   targetObject.add();
 }
}


 

相关文章推荐

SSH学习之——Spring面向方面编程AOP

一:概述 众所周知,Spring是一个轻量级的、非侵入式的、独立于各种应用服务器的开源框架。它的两大方面被人们所熟知,也应用很广。那就是IOC(控制反转)和AOP(面向方面编程)。 IOC是开发者...
  • CYXLZZS
  • CYXLZZS
  • 2012年09月13日 10:50
  • 3629

Spring AOP面向方面编程原理

①AOP概念(1)       AOP(Aspect Oriented Programming),也就是面向方面编程的技术。AOP基于IoC基础,是对OOP的有益补充。 AOP将应用系统分为两部分...

浅析Spring AOP(面向方面编程)

SpringAOP提供的优势 1、允许开发者声明企业级服务,比如:事务服务、安全性服务。EJB组件能够使用J2EE容器提供声明式服务。但是需要借助于EJB组件,而SpringAOP却不需要EJB容器...

Spring 国际化支持 消息传递 以及 AOP 面向方面编程

国际化支持 照书上的流程下来. 设置config.xml messages 建messages.properties文件内容为 ...

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

1.什么是Spring,有什么作用  --Spring框架属于一个解决方案框架,可以对其他技术和框架进行整合应用。  --*好处是:将程序中的各个组件和框架技术进行解耦,便于日后系统维护,升级和扩展操...

Spring - Java/J2EE Application Framework 应用框架 第 5 章 Spring AOP: Spring之面向方面编程

第 5 章 Spring AOP: Spring之面向方面编程 5.1. 概念 面向方面编程 (AOP) 提供从另一个角度来考虑程序结构以完善面向对象编程(OO...

Spring - Java/J2EE Application Framework 应用框架 第 5 章 Spring AOP: Spring之面向方面编程G

第 5 章 Spring AOP: Spring之面向方面编程 5.1. 概念 面向方面编程 (AOP) 提供从另一个角度来考虑程序结构以完善面向对象编程(OOP)。 面向对象将应用...

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

Spring框架的作用:为了简化java开发 Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On...

Spring学习,依赖注入(DI)、控制反转(IoC)和面向切面(AOP)

依赖注入DI和控制反转IoC Spring容器中的依赖注入DI和控制反转IoC xml配置 注解配置 面向切面AOP 面向切面的应用动态代理 Spring容器中的面向切面 xml配置 注解配置 Spr...
  • Nicorui
  • Nicorui
  • 2017年02月13日 15:16
  • 301

面向对象编程(OOP)、面向组件编程(COP)、面向方面编程(AOP)和面向服务编程(SOP)【转】

面向对象编程(OOP)、面向组件编程(COP)、面向方面编程(AOP)和面向服务编程(SOP)【转】2008-12-13 22:471、什么是面向对象编程(Object-Oriented Progra...
  • junecau
  • junecau
  • 2011年04月28日 20:09
  • 410
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:SPRING--Spring中IOC(反转控制) 和 AOP(面向方面编程)
举报原因:
原因补充:

(最多只允许输入30个字)