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();
 }
}


 

Spring的控制反转(IoC)和面向切面编程(AOP)的概念浅析。

转自:http://baike.baidu.com/link?url=BhIdxXwp9Xs7PjzebLL8sisJrgh0MiLUB2clkgpf-rpyexxlKTOXDDCxmX1MYe4qe...
  • suyu_yuan
  • suyu_yuan
  • 2016年09月18日 21:57
  • 4287

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

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

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

Spring框架的作用:为了简化java开发 Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On...
  • h348592532
  • h348592532
  • 2015年05月07日 22:19
  • 2366

spring的IOC(控制反转)与AOP(面向切面编程)

一直对spring的两大特性IOC与AOP了解的模模糊糊,不知道怎么区分,怎么理解。 今天看了一篇讲spring常用注解的文章和spring AOP的文章,引用这两个作者的观点,感觉对这两个特性的了...
  • u013538390
  • u013538390
  • 2015年07月02日 18:24
  • 1544

Spring中IOC与AOP的理解

关于IOC我们知道是Spring中很重要的组合部分,下面就IOC的理解写一点自己的心得: 1.IOC是什么? IOC也称控制反转,其实是和依赖注入的含义是一样的,就是把原先控制代码对象的生产由代码...
  • qq_35347459
  • qq_35347459
  • 2017年04月26日 17:51
  • 579

谈谈Spring中的IOC和AOP概念

IOC和AOP是Spring中的两个核心的概念,下面谈谈对这两个概念的理解。 --------------------------------------------------- 1. IOC(I...
  • eson_15
  • eson_15
  • 2016年04月07日 22:19
  • 19936

深入理解IOC控制反转及应用实例

一、IOC雏形 1、程序V1.0 话说,多年以前UT公司提出一个需求,要提供一个系统,其中有个功能可以在新春佳节之际给公司员工发送一封邮件。邮件中给大家以新春祝福,并告知发放一定数额的...
  • lqw05
  • lqw05
  • 2016年08月14日 16:29
  • 1713

浅谈Spring中IOC和AOP是什么?

解释Spring中的IOC? IOC:Inversion of Control控制反转,也叫(Dependency Injection)依赖注入, dao接口的实现不再是业务逻辑层调用工厂类去获取,...
  • snn1410
  • snn1410
  • 2015年04月21日 17:46
  • 11041

IOC、DI、AOP是什么,为什么使用,怎么用

IOC、DI、AOP是什么,为什么使用,怎么用 Spring中加载配置文件的两种方法,可以加载多个配置文件吗?单例模式、和工厂模式定义 依赖注入的三种方法 1.IOC IOC为控制反转...
  • maidaogo
  • maidaogo
  • 2014年11月25日 09:58
  • 687

谈谈Spring中的IOC、DI和AOP概念

看了大神的解释感觉受益匪浅,所以就将其保存,方便自己看,并最后总结出自己的理解 1. IOC(Inverse of Control):控制反转,也可以称为依赖倒置。      ...
  • Santiago_M
  • Santiago_M
  • 2017年05月05日 10:38
  • 392
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:SPRING--Spring中IOC(反转控制) 和 AOP(面向方面编程)
举报原因:
原因补充:

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