spring依赖注入使用的什么设计模式?
4个回答
2015-08-19 · 知道合伙人数码行家
可以叫我表哥
知道合伙人数码行家
向TA提问 私信TA
知道合伙人数码行家
采纳数:25897
获赞数:1464977
2010年毕业于北京化工大学北方学院计算机科学与技术专业毕业,学士学位,工程电子技术行业4年从业经验。
向TA提问 私信TA
关注
展开全部
依赖注入模式
依赖注入(Dependency Injection) 是一个非常简单的概念,伸手-等待。
如例程1-1所示,Client依赖于抽象类型(甚至是具体类) IServer,蛋是(1)Client的类体中不创建IServer(子类)的对象,它不想自己创建IServer对象,而是提供public的构造器Client(IServer)或设置方法setIServer (IServer)等(伸手),(2)坐等外界将初始化后的IServer对象(的引用)传递进来(等待)。
换言之,依赖注入模式是指客户类Client不用自己来初始化它所依赖的成员变量IServer,而是等待某个对象创建IServer的适当的(实现类)的对象并将它赋值给Client的成员变量。
依赖注入的意义,在于保证Client仅仅与(通常是接口或抽象类)IServer耦合,而不与IServer的子类型耦合,这样的程序符合OCP或依赖于抽象类型原则。
例程 1-1
package creational;
import java.lang.reflect.*; //也可以自己写
import tool.God;
public class Client{
private IServer s;
/**
* 依赖注入
*/
public Client(IServer s){
this.s = s;
}
public void setS(IServer s){
this.s = s;
}
public static void test(){
//使用工具God
IServer s = (IServer) God.create("1-5");
s.m();
}
}
依赖注入(Dependency Injection) 是一个非常简单的概念,伸手-等待。
如例程1-1所示,Client依赖于抽象类型(甚至是具体类) IServer,蛋是(1)Client的类体中不创建IServer(子类)的对象,它不想自己创建IServer对象,而是提供public的构造器Client(IServer)或设置方法setIServer (IServer)等(伸手),(2)坐等外界将初始化后的IServer对象(的引用)传递进来(等待)。
换言之,依赖注入模式是指客户类Client不用自己来初始化它所依赖的成员变量IServer,而是等待某个对象创建IServer的适当的(实现类)的对象并将它赋值给Client的成员变量。
依赖注入的意义,在于保证Client仅仅与(通常是接口或抽象类)IServer耦合,而不与IServer的子类型耦合,这样的程序符合OCP或依赖于抽象类型原则。
例程 1-1
package creational;
import java.lang.reflect.*; //也可以自己写
import tool.God;
public class Client{
private IServer s;
/**
* 依赖注入
*/
public Client(IServer s){
this.s = s;
}
public void setS(IServer s){
this.s = s;
}
public static void test(){
//使用工具God
IServer s = (IServer) God.create("1-5");
s.m();
}
}
展开全部
springMVC通常采用属性注入的IOC方式和AOP织入方式相结合实现依赖注入
同时使用强制代理方式,代理类或者接口。
这里又涉及到单例模式(注入的类或者接口在容器中只存在一个)、工厂模式(通过反射实现类实例化过程的公用化)、楼上所说的装饰模式属于AOP织入的一部分。
想了解spring先从IOC和AOP开始吧。
一、单例模式案例:
一般Singleton模式通常有三种形式:
第一种形式: 也是常用的形式。
public class Singleton {
private static Singleton instance = null;
private Singleton(){
//do something
}
public static Singleton getInstance(){
if(instance==null){
instance = new Singleton();
}
return instance;
}
}
第二种形式:
public class Singleton {
//在自己内部定义自己的一个实例,只供内部调用
private static Singleton instance = new Singleton();
private Singleton(){
//do something
}
//这里提供了一个供外部访问本class的静态方法,可以直接访问
public static Singleton getInstance(){
return instance;
}
}
第三种形式: 双重锁的形式。
public class Singleton {
private static Singleton instance = null;
private Singleton(){
//do something
}
public static Singleton getInstance(){
if(instance==null){
synchronized(Singleton.class){
if(null == instance){
instance = new Singleton();
}
}
}
return instance;
}
}//这个模式将同步内容下方到if内部,提高了执行的效率,不必每次获取对象时都进行同步,只有第一次才同步,创建了以后就没必要了。
二、IOC通过单例模式+工厂模式的实现
抽象类
Java代码
package com.factory;
import com.singleton.Singleton;
public abstract class AbstractFactory {
public abstract Singleton createSingleton();
}
工厂类
Java代码
package com.factory;
import com.singleton.Singleton;
public class Factory extends AbstractFactory{
@Override
public Singleton createSingleton() {
return Singleton.getInstance();
}
}
单例类
Java代码
package com.singleton;
public class Singleton {
private static Singleton instance = null;
public Singleton(){
}
public static synchronized Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
public String testSingleton(){
return "Hello Singleton";
}
}
测试类
Java代码
package com.test;
import com.factory.Factory;
import com.singleton.Singleton;
public class Test {
public static void main(String[] args){
Factory factory = new Factory();
Singleton s = factory.createSingleton();
System.out.print(s.testSingleton());
}
}
三、代理案例
1.定义提供方法的接口
public interface IHello {
public void hello(String name);
}
2.接口实现类
public class HelloSpeaker implements IHello {
public void hello(String name) {
System. out.println("实现类中的hello():" +"Hello " + name);
}
}
3.定义静态代理类注入接口通过实现类实现方法
public class HelloProxy implements IHello {
private IHello iHello ;
public HelloProxy(IHello iHello) {
super();
this.iHello = iHello;
}
public void hello(String name) {
System. out.println("代理类中的hello():" );
iHello.hello(name);
}
}
4.静态代理类测试main方法入口
public class ProxyDemo {
public static void main(String[] args) {
IHello iHello = new HelloProxy(new HelloSpeaker());
iHello. hello("long");
}
}
5.定义动态代理类减少代理类对接口的依赖
public class LogHandler implements InvocationHandler {
private Object implClass ;
public Object bind(Object implClass) {
this.implClass = implClass;
return Proxy.newProxyInstance(implClass.getClass().getClassLoader(),
implClass.getClass().getInterfaces(), this);
}
/**
* 代理对象,这里面还可以改变原有的方法
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
try {
System. out.println("添加日志" );
result = method.invoke( implClass, args);
} catch (Exception e) {
e.printStackTrace();
}
return null ;
}
}
6.动态代理类的测试主入口
public class ProxyDt {
public static void main(String[] args) {
LogHandler logHandler = new LogHandler();
IHello iHello = (IHello) logHandler.bind( new HelloSpeaker());
iHello.hello( "long");
}
}
四、利用ProxyFactory连接CGLIB简单实现AOP:
加入包aopalliance.jar\cglib-nodep-2.1_3.jar demo:
view plaincopy to clipboardprint?
package cn.partner4java.proxy.proxyfactory;
/**
* 被代理的对象
* @author partner4java
*
*/
public class MessageWriter {
public void writeMessage(){
System.out.println("world!");
}
}
package cn.partner4java.proxy.proxyfactory;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/**
* 装饰者<br/>
* MethodInterceptor接口是对方法调用连接点实现包围通知的AOP联盟标准接口
* @author partner4java
*
*/
public class MessageDecorator implements MethodInterceptor{
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.print("Hello ");
Object retVal = invocation.proceed();
return retVal;
}
}
package cn.partner4java.proxy.proxyfactory;
import org.springframework.aop.framework.ProxyFactory;
/**
* 调用组装
* 这里最重要的部分是我们使用ProxyFactory来创建一个目标对象代理,同时织入通知
* @author partner4java
*
*/
public class HelloWorldWeaver {
public static void main(String[] args) {
//目标
MessageWriter target = new MessageWriter();
//create the proxy
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.addAdvice(new MessageDecorator());
proxyFactory.setTarget(target);
//获取返回被代理的目标
MessageWriter proxy = (MessageWriter) proxyFactory.getProxy();
target.writeMessage();
System.out.println("---");
proxy.writeMessage();
// 后台打印:
// world!
// ---
// Hello world!
}
}
本回答被提问者和网友采纳
已赞过
已踩过<
评论
收起
你对这个回答的评价是?
展开全部
从上面代码可以看到,spring依赖注入时,使用了双重判断加锁的单例模式,首先从缓存中获取bean实例,如果为null,对缓存map加锁,然后再从缓存中获取bean,如果继续为null,就创建一个bean。这样双重判断,能够避免在加锁的瞬间,有其他依赖注入引发bean实例的创建,从而造成重复创建的结果。
在这里Spring并没有使用私有构造方法来创建bean,而是通过singletonFactory.getObject()返回具体beanName对应的ObjectFactory来创建bean。我们一路跟踪下去,发现实际上是调用了AbstractAutowireCapableBeanFactory的doCreateBean方法,返回了BeanWrapper包装并创建的bean实例。
(ObjectFactory主要检查是否有用户定义的BeanPostProcessor后处理内容,并在创建bean时进行处理,如果没有,就直接返回bean本身
在这里Spring并没有使用私有构造方法来创建bean,而是通过singletonFactory.getObject()返回具体beanName对应的ObjectFactory来创建bean。我们一路跟踪下去,发现实际上是调用了AbstractAutowireCapableBeanFactory的doCreateBean方法,返回了BeanWrapper包装并创建的bean实例。
(ObjectFactory主要检查是否有用户定义的BeanPostProcessor后处理内容,并在创建bean时进行处理,如果没有,就直接返回bean本身
已赞过
已踩过<
评论
收起
你对这个回答的评价是?
展开全部
单例模式 工厂模式 装饰者模式 很多很多的....
更多追问追答
追问
用到代理模式了吗?
追答
代理模式有的
懒加载都是代理模式
已赞过
已踩过<
评论
收起
你对这个回答的评价是?
推荐律师服务:
若未解决您的问题,请您详细描述您的问题,通过百度律临进行免费专业咨询