初始Spring 详解

// 值代码中, 通过局部变量, 方法参数, 返回值等.. 建立于对其它对象的调用关系; 
// 例如在：A类方法中 实例化 B类型的对象, 并调用其方法完成某种功能.. 就可以称为： `A类依赖于B类;
// 几乎所有应用程序,都是由两个及以上的类,通过彼此合作实现完整的功能 . 类于类之间的依赖关系, 增加了程序开发的复杂程度; 我们在开发一个/修改类的时候，还需要考虑使用该类的类 的影响;
is  是		子类继承父类 即 子类 is 父类;
has 包含	A类依赖B类	即 A类 has B类;

public class Cart {
	//这里车有两个属性：品牌 和 发动机; 因为车是依赖于发动机的所以 有一个发动机类型;
	//这里发动机是个接口类型,以表示多种发动机可选性; 
	public String brand;//品牌
	public Fdj fdj;//发动机
	//初始化
	public void init(){
		System.out.println("品牌："+this.brand);
		//打印发动机;
		fdj.show(); 
	}
	//get/set方法;
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public Fdj getFdj() {
		return fdj;
	}
	public void setFdj(Fdj fdj) {
		this.fdj = fdj;
	}
}

public interface Fdj {
	//打印当前发动机; 每一个继承发动机接口的 发动机子类都要实现改方法..
	public void show();
}

public class BenTianFdj implements Fdj {

	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("本田发动机");
	}

}

public class SanLingFdj implements Fdj {
	@Override
	public void show() {
		System.out.println("三菱发动机");
	}
}

public class Test {
	public static void main(String[] args) {
		Cart c = new Cart();
		//假设要  大众的品牌
		c.setBrand("大众");  
		//假设要 三菱发动机则;
		c.setFdj(new SanLingFdj());
		//最后结果;
		c.init();
	}
}

public class CartFactory {
	//制作汽车方法;
	public Cart createCart(String brand, String fdj) {
		Cart cart = new Cart();
		cart.setBrand(brand);
		if (fdj.equals("本田")) {
			BenTianFdj ben = new BenTianFdj();
			cart.setFdj(ben);
		} else if (fdj.equals("三菱")) {
			SanLingFdj san = new SanLingFdj();
			cart.setFdj(san);
		}
		return cart;
	}
}

public class Test {
	public static void main(String[] args) {
		//创建 汽车工厂;
		CartFactory cartFactory = new CartFactory();
		//生产汽车对象;
		Cart c = cartFactory.createCart("大众","三菱");
		//输出;
		c.init(); 
	}
}

<?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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
	
	
	<!-- Spring使用<Bean />标签：进行依赖注入 完成控制反转,实例化类操作; 
		属性：
			id:			值唯一, 表示定义Bean实例的名称;
			class:		表示定义Bean实例的类型; 值就是表示类的: 引用类路径; 
						Myelicpse: 还可以观察类文件图标有没有出现S 来确定类是否被 Spring容器管理！
		子元素:
			<property name="Bean的属性名" />	
				<value>基本数据类型,直接赋值</value> 
							或 
				<ref bean="复杂数据类型Bean，直接引用其ID 即可(就相当于new一样)" >												
			</property>		
			
	 			
	 -->	
	<!-- 因为本田/三菱类并没有属性,所以就这样就完了... -->
	<bean id="BT" class="com.wsm.spring.BenTianFdj" ></bean> <!-- 本田发动机 -->
	<bean id="SL" class="com.wsm.spring.SanLingFdj" ></bean> <!-- 三菱发动机 -->
	
	<bean id="cart" class="com.wsm.spring.Cart" >
		<property name="brand" value="大众"  />	 <!-- 给基本类型属性brand 直接赋值 -->
		<property name="fdj"   ref="BT"   	 />  <!-- 给复杂类型属性fdj   引用其bean id赋值 -->
		<!-- 
			注意：这里表面上是 根据属性名赋值,实际上内部是调用了属性的 setxx(); 被称为 "设值注入"
				  所以一定要注意JavaBean命名规范,而且  如果没 get/set 则会编译报错...
			eg:   如果 name="name" 则底层调用 setName();  aa 则 setAa();...
		 -->	
	</bean>
	
	
</beans>

package com.wsm.spring;

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

public class Test {
	public static void main(String[] args) {
		//通过 ClassPathXmlApplicationContext 实例化 Spring 上下文;
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//通过 ApplicationContext 的getBean("Bean的Id"); 获取对应的Bean 的实例,返回Object类型;
		Cart c = (Cart)context.getBean("cart"); //强转为 Cart类型对象;
		//调用方法;
		c.init();
	}
	/*
	 * ApplicationContext 是一个接口,负责读取Spring 配置文件;
	 * 		管理对象加载,维护Bean对象与Bean对象之间的依赖关系; 负责Bean的生命周期; 
	 * ClassPathXmlApplicationContext 是 ApplicationContext 的实现类:
	 * 		从 classpath路径读取Spring配置文件;
	 * */
	 
}	

public class Aop {
	private Logger log = Logger.getLogger(Aop.class);
	
	//前置增强			//连接点对象
	public void beforeee(JoinPoint joinPoint){
		log.info("前置,调用" + joinPoint.getTarget() + "类,下的方法是"
				+ joinPoint.getSignature().getName() + ",方法的参数是:"
				+ Arrays.toString(joinPoint.getArgs()));
	}
	//后置增强				//连接点对象,返回值
	public void afterReting(JoinPoint joinPoint,Object result){  
		log.info("后置,调用" + joinPoint.getTarget() + "类,下的方法是"
				+ joinPoint.getSignature().getName() + ",方法的参数是:"
				+ Arrays.toString(joinPoint.getArgs()) + ",方法的返回值是：" + result);
	}
	/*
	JoinPoint 连接点对象;
	为了能够在增强方法中获得当前连接点的信息，以便实施相关的判断和处理，
	可以在增强方法中声明一个JoinPoint类型的参数。
	Spring会自动注入实现该实例。
	通过该实例的getTarget( )    方法可以得到被代理的目标对象，!!!
	getSignature( )方法返回被代理的目标方法，
	getArgs( )方法返回传递给目标方法的参数数组。
	对于实现后置增强的afterReturning( )方法，还可以定义一个参数用于接收目标方法的返回值。
	*/
}

<?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:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop"   
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">
	<!-- 引入命名空间：xmlns:aop="http://www.springframework.org/schema/aop" -->
	<!-- 省略了之前的代码..注意哦 -->
	
	<!-- <aop:config>中完成织入 -->
	<aop:config>
		<aop:pointcut expression="execution (public String init())" id="mypoint"/>
		<!--
			配置切入点的标签<aop:pointcut>
			<aop:pointcut>的expression属性可以配置切入点表达式：切入点表达式支持模糊匹配，讲解几种常用的模糊匹配:
				public * addNewUser(entity.User)  	 “*”表示匹配所有类型的返回值。
				public void *(entity.User)		“*”表示匹配所有方法名。
				public void addNewUser(..)		“..”表示匹配所有参数个数和类型。
				* com.service.*.*(..)			匹配com.service包下所有类的所有方法。
				* com.service..*.*(..)		匹配com.service包及其子包下所有类的所有方法
				....等等;  Myelicpse工具也可以根据,一些小箭头 
		-->
		<aop:aspect ref="myLogAop">  <!-- aspect:切面,切入点和增强组成..  ref:引入增强处理类,类对象 -->
			<!-- 前置增强：      前置的方法名();	        切入点                               -->
			<aop:before method="beforeee" pointcut-ref="mypoint"/>
			 <!-- 后置增强：                后置方法名();				  切入点           返回值参数名; -->
			 <aop:after-returning method="afterReting" 	pointcut-ref="mypoint"	 returning="result"/> 
		</aop:aspect>
	
	</aop:config>
	
	<!-- 增强处理类 -->
	<bean id="myLogAop"  class="com.wsm.aop.Aop"></bean> 

</beans>