Java学习08 (第一遍) - SpringMVC

写一下午的好多居然丢失。。。自动保存也只是保存丢失后的

那就不多写了，简单写：

Spring：（自己画的）

官网的：

写一个Spring的例子：

Eclipse

http://repo.spring.io/release/org/springframework/spring/4.3.9.RELEASE/

http://commons.apache.org/proper/commons-logging/download_logging.cgi

https://github.com/junit-team/junit4/wiki/Download-and-Install

IoC:

反向控制，依赖注入，实现主动方成为被动方，IoC容器启动时就实例化所有Beans，不用再等待使用JavaBean时去请求依赖的类，而是将曾经依赖的类注入到JavaBean中，实现实例化，Spring常用3种注入方式：1。接口（依赖类设置为接口，方便自动注入，也方便子类实现-（DIP原则/LSP原则））

2。gettersetter（JavaBean的定义，封装性）

3。构造器（全参）

IoC将耦合分离到配置文件中了。

AoP（两个流行的框架：Spring AOP和AspectJ）

应用横切关注点(cross-cutting concern)：日志记录，性能统计，安全控制，权限管理，事务处理，异常处理，缓存，资源池管理。

横切简单说就是将多种需求分解不同方面，将业务夹在中间，OOP（面对对象编程）是从静态角度考虑程序结构，但AOP则是动态角度考虑程序的运行过程。

AoP实际上是一个目标类的代理类实现的，AOP在一个特定切点添加了增强处理，并回调了目标对象。

所以要先学习动态代理技术：

代理Proxy学习，为什么要用代理类？：它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

接口：

public interface IHello

{

void say(String name);

}

实现类：

public class HelloImpl implements IHello

{

@Override

public void say(String name){

System.out.println("Hello "+ name);

}

}

静态代理类 （可以对接口或抽象类）:

public class HelloProxy implements Hello

{

private IHello hello;

public HelloProxy(){

hello=new HelloImpl(); //构造器注入，

}

@Override

void say(String name){

before();

hello.say(name);

after();

}

private before(){

System.out.println("before");

}

private after(){

System.out.println("after");

}

}

动态代理类（对接口，在Spring中，提供了多种代理，利用jdk中api，需要提供接口。而cglib是不需要的，可以直接创建类的Proxy,Jdk通过java.lang.reflect.Proxy来支持动态代理，一般情况下，使用方法newProxyInstanceof来创建Proxy类，而对于InvocationHandler，需要实现它的invoke方法，在调用代理对象中的每一个方法时，在代码内部，都是直接调用了InvocationHandler的invoke方法，而invoke方法根据代理类传递给自己的method参数来区分是什么方法。 该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值,该类还实现了invoke方法，该方法中的method.invoke(sub,args); 其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，args为执行被代理对象相应操作所需的参数）：

JDK：

public class DynamicProxy implements InvocationHandler

{

private Object target;

public DynamicProxy(Object target){ //构造器注入

this.target=target;

}

@Override

public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{

before();

Object result=method.invoke(target,args);

after()

return result;

}

private before(){

System.out.println("before");

}

private after(){

System.out.println("after");

}

}

使用：

public static void main(String [] args){

Hello hello=new HelloImpl();

DynamicProxy dynamicProxy=new DynamicProxy(hello);

Hello helloProxy=(Hello)Proxy.newProxyInstance(

hello.getClass().getClassLoader(),hello.getClass().getInterfaces(),dynamicProxy);

helloProxy.say("you");

}

Proxy.newProxyInstance方法的参数:1.ClassLoader,2.实现类的所有接口，3.动态代理对象，最后还需要强制类型转换

重构（refactor）一下：

public class DynamicProxy implements InvocationHandler

{

private Object target;

public DynamicProxy(Object target){ //构造器注入

this.target=target;

}

@SuppressWarnings("unchecked") //Object强制转为泛型，编译会警告

public<T> T getProxy(){

return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);  //利用泛型的反射来获取。

}

@Override

/**

* 同过代理对象调用方法首先进入这个方法.

* @param proxy --指代我们所代理的那个真实对象

* @param method --指代的是我们所要调用真实对象的某个方法的Method对象，方法,被调用方法.

* @param args -- 方法的参数

*/

public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{

before();

Object result=method.invoke(target,args);

after()

return result;

}

private before(){

System.out.println("before");

}

private after(){

System.out.println("after");

}

}

使用：

public static void main(String [] args){

Hello hello=new HelloImpl();

DynamicProxy dynamicProxy=new DynamicProxy(hello);

//Hello helloProxy=(Hello)Proxy.newProxyInstance(hello.getClass().getClassLoader(),hello.getClass().getInterfaces(),dynamicProxy);

Hello helloProxy=dynamicProxy.getProxy();

helloProxy.say("you");

}

CGlib:

CGlib可以代理没有接口的类，提供MethodInterceptor实现类，并填充intercept方法，CGlib提供的是方法级别的代理，也可理解为对方法的拦截。

先看下:Singleton

Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。” //一个系统只能有一个计时工具或ID(序号)生成器。

Java单例模式例子，不能使用new关键字实例化对象：

1 2 3 4 5 6 7 8 9 10 11 12

public class SingletonClass{     private static volatile SingletonClass instance=null;     public static SingletonClass getInstance(){             synchronized(SingletonClass.class){                 if(instance==null){                     instance=new SingletonClass();                 }             }         return instance;     }     private SingletonClass(){} }