月度归档： 2019年11月

通过New Thread的方式

LiftOff.java

package concurrency;

public class LiftOff implements Runnable{
    protected int countDown = 10; //Default
    private static int taskCount = 0;
    private final int id = taskCount++;
    public LiftOff(){}
//    public LiftOff(int countDown){
//        this.countDown = countDown;
//    }
    public String status(){
        return "#" + id + " (" + (countDown > 0 ? countDown : "Liftoff!") + ")";
    }

    public void run() {
        while(countDown-- > 0){
            System.out.println(status());
            Thread.yield();
        }
    }
}

使用了总是分配给main()的那个线程

MainThread.java

package concurrency;

public class MainThread {
    public static void main(String[] args) {
        LiftOff launch = new LiftOff();
        launch.run();
    }
}

Thread构造器只需要一个Runnable对象,调用Thread对象的start()方法为该线程执行必须的初始化操作.

然后调用 Runnable的run()方法,以便在这个新线程中启动该任务.

BasicThreads.java

package concurrency;

public class BasicThreads {
    public static void main(String[] args) {
        Thread t = new Thread(new LiftOff());
        t.start();
        System.out.println("Waiting for LiftOff");
    }
}

java.lang.reflect.Proxy：该类用于动态生成代理类，只需传入目标接口、目标接口的类加载器以及InvocationHandler便可为目标接口生成代理类及代理对象。

// 方法 1: 该方法用于获取指定代理对象所关联的InvocationHandler
static InvocationHandler getInvocationHandler(Object proxy) 
// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
static Class getProxyClass(ClassLoader loader, Class[] interfaces) 
// 方法 3：该方法用于判断指定类是否是一个动态代理类
static boolean isProxyClass(Class cl) 
// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)

JDK中的动态代理是通过反射类Proxy以及InvocationHandler回调接口实现的;但是，JDK中所要进行动态代理的类必须要实现一个接口，也就是说只能对该类所实现接口中定义的方法进行代理，这在实际编程中具有一定的局限性，而且使用反射的效率也并不是很高。

要生成某一个对象的代理对象，这个代理对象通常也要编写一个类来生成，所以首先要编写用于生成代理对象的类。在java中如何用程序去生成一个对象的代理对象呢，java在JDK1.5之后提供了一个"java.lang.reflect.Proxy"类，通过"Proxy"类提供的一个newProxyInstance方法用来创建一个对象的代理对象，如下所示：

示例业务逻辑：

1-娱乐明星都会唱歌、演习(interface Star)

2-有一个明星叫胡歌（class HuGe implements Star）

3-他有两个助理(分别对应两个代理类)(class HuGeProxy1、class HuGeProxy2)

4-如果要找胡歌唱歌、演戏，需要先找两个助理中的一个，然后助理去找胡歌唱歌、演戏（class ProxyTest）

package com.huishe.testOfSpring.proxy;
//定义一个明细接口
public interface Star {
    void sing(String song);//唱歌
    
    String act(String teleplay);//表演
}

package com.huishe.testOfSpring.proxy;
//创建胡歌类-实现明细接口
public class HuGe implements Star{
    public void sing(String song) {
        System.out.println("胡歌演唱： " + song);
    }
    public String act(String teleplay) {
        System.out.println("胡歌决定出演电视剧： " + teleplay);
        return "胡歌答应出演电视剧： " + teleplay;
    }
}

package com.huishe.testOfSpring.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//胡歌代理类1
//使用一个匿名内部类来实现该接口实现InvocationHandler接口,实现invoke方法
public class HuGeProxy1 {
    private Star hg = new HuGe();//实例化一个对象
    
    public Star getProcxy(){
        //使用Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)返回某个对象的代理对象
        /**
         * ClassLoader loader:Java类加载器; 可以通过这个类型的加载器，在程序运行时，将生成的代理类加载到JVM即Java虚拟机中，以便运行时需要！
         * Class<?>[] interfaces:被代理类的所有接口信息; 便于生成的代理类可以具有代理类接口中的所有方法
         * InvocationHandler h:调用处理器; 调用实现了InvocationHandler 类的一个回调方法
         * */
        return (Star)Proxy.newProxyInstance(
                getClass().getClassLoader(), 
                hg.getClass().getInterfaces(), 
                new InvocationHandler() {
                    /**
                      * InvocationHandler接口只定义了一个invoke方法，因此对于这样的接口，我们不用单独去定义一个类来实现该接口，
                      * 而是直接使用一个匿名内部类来实现该接口，new InvocationHandler() {}就是针对InvocationHandler接口的匿名实现类
                      */
                     /**
                      * 在invoke方法编码指定返回的代理对象干的工作
                      * proxy : 把代理对象自己传递进来 
                      * method：把代理对象当前调用的方法传递进来 
                      * args:把方法参数传递进来
                      * 
                      * 当调用代理对象的star.sing("逍遥叹");或者 star.act("琅琊榜")方法时，
                      * 实际上执行的都是invoke方法里面的代码，
                      * 因此我们可以在invoke方法中使用method.getName()就可以知道当前调用的是代理对象的哪个方法
                      */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        
                        if(method.getName().equals("sing")){
                            System.out.println("我是胡歌代理1，找胡歌唱歌找我");
                            return method.invoke(hg, args);
                        }
                        if(method.getName().equals("act")){
                            System.out.println("我是胡歌代理1，找胡歌演电视剧找我");
                            return method.invoke(hg, args);
                        }
                        
                        return null;
                    }
                });
    }
}

package com.huishe.testOfSpring.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//胡歌代理类2
//实现InvocationHandler接口,实现invoke方法
public class HuGeProxy2 implements InvocationHandler{
    private Star hg = new HuGe();
    
    public Star getProcxy(){
        return (Star)Proxy.newProxyInstance(
                getClass().getClassLoader(), 
                hg.getClass().getInterfaces(), 
                this);
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        if(method.getName().equals("sing")){
            System.out.println("我是胡歌代理2，找胡歌唱歌找我");
            return method.invoke(hg, args);
        }
        if(method.getName().equals("act")){
            System.out.println("我是胡歌代理2，找胡歌演电视剧找我");
            return method.invoke(hg, args);
        }
        
        return null;
    }
    
    
    
}

package com.huishe.testOfSpring.proxy;
import org.junit.Test;
public class ProxyTest {
    //测试代理类1
    @Test
    public void testHuGeProxy1(){
        
        HuGeProxy1 proxy = new HuGeProxy1();//找到胡歌的助理
        Star hg = proxy.getProcxy();//助理和胡歌洽谈
        hg.sing("《逍遥叹》");//(胡歌答应后)唱歌
        String actResult = hg.act("《琅琊榜》");//(胡歌答应后)演习
        System.out.println("演出结果：" + actResult);
    }
    //测试代理类1
    @Test
    public void testHuGeProxy2(){
        
        HuGeProxy2 proxy = new HuGeProxy2();
        Star hg = proxy.getProcxy();
        hg.sing("《逍遥叹》");
        String actResult = hg.act("《琅琊榜》");
        System.out.println("演出结果：" + actResult);
    }
    
}

代理1日志输出：

我是胡歌代理1，找胡歌唱歌找我

胡歌演唱： 《逍遥叹》

我是胡歌代理1，找胡歌演电视剧找我

胡歌决定出演电视剧： 《琅琊榜》

演出结果：胡歌答应出演电视剧： 《琅琊榜》

代理2日志输出：

我是胡歌代理2，找胡歌唱歌找我

胡歌演唱： 《逍遥叹》

我是胡歌代理2，找胡歌演电视剧找我

胡歌决定出演电视剧： 《琅琊榜》

演出结果：胡歌答应出演电视剧： 《琅琊榜》

简单代理:

package typeinfo;

interface Interface {
    void doSomething();

    void doSomethingElse(String arg);
}

class RealObject implements Interface {

    @Override
    public void doSomething() {
        System.out.println("doSomething");
    }

    @Override
    public void doSomethingElse(String arg) {
        System.out.println("SomethingElse " + arg);
    }
}

class SimpleProxy implements Interface {
    private Interface proxied;

    public SimpleProxy(Interface proxied) {
        this.proxied = proxied;
    }

    @Override
    public void doSomething() {
        System.out.println("SimpleProxy doSomething");
        proxied.doSomething();
    }

    @Override
    public void doSomethingElse(String arg) {
        System.out.println("SimpleProxy doSomethingElse" + arg);
        proxied.doSomethingElse(arg);
    }
}

public class SimpleProxyDemo {
    public static void consumer(Interface iface){
        iface.doSomething();
        iface.doSomethingElse("bonobo");
    }

    public static void main(String[] args) {
        consumer(new RealObject());
        consumer(new SimpleProxy(new RealObject()));
    }
}

动态代理:

package typeinfo;

import java.lang.reflect.*;

class DynamicProxyHandle implements InvocationHandler {
    private Object proxied;

    public DynamicProxyHandle(Object proxied) {
        this.proxied = proxied;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("****** proxy: " + proxy.getClass() + ", method: " + method + ", args: " + args);
        if (args != null) {
            for (Object arg : args)
                System.out.println("  " + arg);
        }
        return method.invoke(proxied, args);
    }
}

public class SimpleDynamicProxy {
    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.doSomethingElse("bonobo");
    }

    public static void main(String[] args) {
        RealObject real = new RealObject();
        consumer(real);
        //Insert a proxy and call again:
        Interface proxy = (Interface) Proxy.newProxyInstance(Interface.class.getClassLoader(),
                new Class[]{Interface.class},
                new DynamicProxyHandle(real));
        consumer(proxy);
    }
}

可以查看方法名

package typeinfo;

import java.lang.reflect.*;

class MethodSelector implements InvocationHandler {
    private Object proxied;

    public MethodSelector(Object proxied) {
        this.proxied = proxied;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().equals("interesting"))
            System.out.println("Proxy detected the interesting method");
        return method.invoke(proxied, args);
    }
}

interface SomeMethods {
    void boring1();

    void boring2();

    void interesting(String arg);

    void boring3();
}

class Implementaction implements SomeMethods {

    @Override
    public void boring1() {
        System.out.println("boring1");
    }

    @Override
    public void boring2() {
        System.out.println("boring2");
    }

    @Override
    public void interesting(String arg) {
        System.out.println("interesting " + arg);
    }

    @Override
    public void boring3() {
        System.out.println("boring3");
    }
}

class SelectingMethods {
    public static void main(String[] args) {
        SomeMethods proxy = (SomeMethods)Proxy.newProxyInstance(
                SomeMethods.class.getClassLoader(),
                new Class[]{SomeMethods.class},
                new MethodSelector(new Implementaction())
        );
        proxy.boring1();
        proxy.boring2();
        proxy.interesting("bonobo");
        proxy.boring3();
    }
}