西安领航培训Spring3视频教程_源码

firemail · 发表于 2016-12-4 23:37:43

链接：http://pan.baidu.com/s/1hrAPHY0 密码：ytcu

firemail · 发表于 2016-12-4 23:45:07

http://www.icoolxue.com/album/show/51

jeesite · 发表于 2017-2-28 21:36:02

本帖最后由 jeesite 于 2017-3-5 11:44 编辑

IOC概念解析

Spring是一个IOC容器，利用DI技术管理对象之间的依赖！
---IOC: Inversion of Control(控件反转)
---DI: Dependency Injection(依赖注入)

简单理解就是: new一个对象 new Message();
转成字符串配置
msg = MessageFactroy.create("2");

1=cn.com.xalead.spring.Message
2=cn.com.xalead.spring.NewMesssage

如下依赖关系表示yyif
、A类是B类中的（某中方法的）局部变量；

public class UserAction implements BeanFactoryAware{
private UserManager manager = null;
public void setManager(UserManager manager) {
this.manager = manager;
}
//////////////////

复制代码

<bean id="userManager" class="cn.com.xalead.spring.UserManager" scope="prototype">  多例
               <property name="username"> 内部变量
                        <value>root</value>
               </property>
               <property name="password">
                        <value>root</value>
               </property>
               <property name="url">
                        <value>jdbc:mysql://localhost:8080/3305</value>
               </property>
         </bean>
         <bean id="userAction" class="cn.com.xalead.spring.UserAction" scope="singleton">  单例
               <property name="manager">  内部变量
                        <ref parent="userManager"/>  依赖注入  引用对象
               </property>
         </bean>

可以用 local  parent(淘汰) 和 bean 指定对象引用范围

set方法（属性）注入

<bean id="userAction" class="cn.com.xalead.spring.UserAction" scope="singleton">
<property name="manager">
<ref bean="userManager"/>
</property>
<property name="list">
<list>
<value>2222</value>
<ref local="cur"/>
</list>
</property>
<property name="set">
<set>
<value>Hello</value>
<value>234.22</value>
<value>22222</value>
<value type="java.lang.String">true</value>
</set>
</property>
<property name="map">
<map>
<entry key="a1">
<value>afasfdsfa</value>
</entry>
<entry key="a2">
<value>34345</value>
</entry>
</map>
</property>
<property name="props">
<props>
<prop key="x1">adsfas</prop>
<prop key="x2">34534</prop>
</props>
</property>
</bean>
<bean id="cur" class="java.util.Date"/>

复制代码

构造注入及注意事项不能循环调用

<bean id="a" class="cn.com.xalead.spring.A">
<constructor-arg index="4" ref="cur"/>
<constructor-arg value="10"/>
<constructor-arg value="zhangsan"/>
<constructor-arg value="1111"/>
<constructor-arg value="M"/>
</bean>

复制代码

自动注入

<bean id="userAction" class="cn.com.xalead.spring.UserAction"
scope="singleton" autowire="byType"/>

复制代码

jeesite · 发表于 2017-3-5 12:13:58

本帖最后由 jeesite 于 2017-3-5 13:11 编辑

通过注解注入

<context:annotation-config/>

复制代码

public class UserAction{
@Resource
private UserManager manager = null;

复制代码

自动组件扫描及分层

<context:component-scan base-package="cn.com.xalead"/>
@Service("userService")
public class UserService {
@Resource(name="userManager")
private UserManager userManager;
@Repository("userManager")
public class UserManager {
@Controller("uAction")
//@Scope("prototype")
public class UserAction{
@Resource(name="userService")
private UserService userService;

复制代码

@Service @Repository @Controller 作用都等同于 @Component 把对应在类在类中注入不用再单独写到xml文件

jeesite · 发表于 2017-3-5 14:26:22

本帖最后由 jeesite 于 2017-3-5 15:04 编辑

使用Spring的最大理由：
---Spring拥有声明式的事务管理的能力
---在Spring之前，只有EJB能做到这一点

编程式事务管理的两难选择

AOP（Aspect-OrientedProgramming，面向方面编程）
要设计良好的架构，必须做到关注点分离，这样可以产生高内聚、
低耦合的系统，这是美丽的终极原则。
AOP也是关注分离思想的一种体现。
EJB(sun的JavaEE服务器端组件模型 Enterprise JavaBean)技术虽然在后期受到了一些诟病，
但是它的架构设计总体上仍然是非常漂亮的。
EJB实现了分布式计算、持久、实例化、缓冲、事务、安全性等关注点的分离。

穿衣 //关注点
吃饭 //关注点
工作.... //真正业务
吃饭  //关注点
睡觉  //关注点

分离方进化：
1.面向过程编程，封装到独立的函数中。
2.由不同的类实现（OOP）
3.提取接口由代理类实现关注点功能，直接调用代理的接口类功能 (做正事之前后进行拦截)  ---静态代理  面向切面的编程
严重问题：
我的侍从与皇帝的太监实现相同的功能，要重写相同代码

通过动态代理  解决

java · 发表于 2017-3-12 12:29:13

AOP（Aspect-OrientedProgramming，面向方面编程）基于动态代理实现

<bean id="m" class="cn.com.xalead.spring.DynamicProxyFactory" factory-method="newInstance">
<constructor-arg ref="me"/>
<constructor-arg ref="servant01"/>
<constructor-arg ref="servant02"/>
<constructor-arg ref="servant03"/>
<constructor-arg ref="servant04"/>
</bean>
<bean id="k" class="cn.com.xalead.spring.DynamicProxyFactory" factory-method="newInstance">
<constructor-arg ref="king"/>
<constructor-arg ref="servant01"/>
<constructor-arg ref="servant02"/>
<constructor-arg ref="servant03"/>
<constructor-arg ref="servant04"/>
</bean>

复制代码

public class DynamicProxyFactory implements InvocationHandler{
private DynamicProxyFactory(){}
private Servant01 servant01;
private Servant02 servant02;
private Servant03 servant03;
private Servant04 servant04;
private Object target;//目标对象
/**
* 创建代理类对象的方法
* @param target 准备创建的代理类要代理的目标对象
*/
public static Object newInstance(Object target,Servant01 servant01,Servant02 servant02,Servant03 servant03,Servant04 servant04){
DynamicProxyFactory dp = new DynamicProxyFactory();
dp.servant01 = servant01;
dp.servant02 = servant02;
dp.servant03 = servant03;
dp.servant04 = servant04;
dp.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader()
, target.getClass().getInterfaces(),
dp);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
servant01.makeBeds();//关注点
servant02.dress();//关注点
servant03.haveAMeal();//关注点
Object o = method.invoke(target, args);//调用动态代理类代理的目标对象上的方法(真正要调用的业务方法)
servant03.haveAMeal();//关注点
servant01.makeBeds();//关注点
servant04.undress();//关注点
return o;
}
}

复制代码

		自动登录	找回密码
密码			立即注册