为了账号安全,请及时绑定邮箱和手机立即绑定

spring依赖注入使用的什么设计模式?

/ 猿问

spring依赖注入使用的什么设计模式?

动漫人物 2018-12-30 00:00:47

spring依赖注入使用的什么设计模式?


查看完整描述

1 回答

?
慕尼黑8549860


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

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;  

   

/** 

* 装饰者 

* 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!  

    }  

   

}


 


查看完整回答
反对 回复 2019-01-16
  • 1 回答
  • 0 关注
  • 325 浏览
我要回答

相关问题推荐

添加回答

回复

举报

0/150
提交
取消
意见反馈 帮助中心 APP下载
官方微信