java设计模式(8)--代理模式

CST STUDIO SUITE 2023安装 破解工具的Crack文件夹内有一个名为「CST Studio Suite 2022」的文件夹,这也是于CST的安装目录同名的文件夹,直接把它拷贝到CST Studio Suite 2022的同级路径下即可,比如你的CST安装路径为:D:\Program Files\CST Studio Suite 2022,则将Crack目录内的「CST Studio Suite 2022」文件夹复制到 D:\Program Files\ 这个级别的路径下即可。软件百度网盘链接放在文章末尾啦!先不着急启动CST或者激活。 阅读详情

最近学习spring-aop内容时,提到了代理模式,粗略了解了一下,发现代理模式实现的功能挺强大的,在很多地方都有用到,所以在此整理一下自己所了解的一些关于代理模式的一些知识。

一、概念(理解概念很重要,个人比较喜欢带着概念去理解代码。)
1.代理:生活中代理这个词很常见,没错我说的这个代理就是你现在头脑正在想的那个代理。
在生活中当我们客户不能直接或不想直接接触目标服务时,或者目标服务所提供的服务对客户有所不足时,我们就引入了代理。
example:火车站太远了,天太冷不想去,于是我们选择去了火车票代售点。这里的代售点也就成了代理,(但这里要注意的是这里虽然是票是代售点给的,但实际票还是来自火车站发放的。1代售点很近我们很快就能买到票,2但是却要收手续费5元,这两个情况也是代售点给我们带来的额外服务(虽然第二个我很不想要))
2.代理模式:代理模式给某一个对象提供一个代理对象,用来控制真实对象访问时的权限以及实现客户端与目标对象的沟通,还有添加额外目标对象所没有的的额外服务(如一些日志事物处理等)。
3.代理模式结构(四个角色)
● 抽象主题角色:声明了目标对象和代理对象的共同接口,这样一来在任何可以使用目标对象的地方都可以使用代理对象。

  ● 真实主题角色:定义了代理对象所代表的目标对象,真正实现业务逻辑的类

  ● 代理主题角色:代理对象内部含有目标对象的引用,从而可以在任何时候操作目标对象;代理对象提供一个与目标对象相同的接口。代理对象通常在客户端调用传递给目标对象之前或之后,执行某个操作,而不是单纯地将调用传递给目标对象。它可以增加一些真实主题里面没有的功能。
  ● Main:客户端,使用代理类和主题接口完成一些工作。
代理模式可分为两大类:静态代理和动态代理
静态代理:对于指定类编写该类的代理类,在程序编译器该类.class文件就已经存在
类图结构如下:这里写图片描述

实例代码:

  • 抽象主题角色

package com.yc.Interface;
//订票,改签, 退票--》抽象主题角色
public interface RailwayStation {
        public void ByTicket();
        public void changeTicket();
        public void exitTicket();
}
  • 真实主题角色
package com.yc.Impl;

import com.yc.Interface.RailwayStation;
//实现类,具体的方法实现--》真实主题角色
public class RailwayStationImpl implements RailwayStation {

    @Override
    public void ByTicket() {
        System.out.println("成功购买一张票");
    }
    @Override
    public void changeTicket() {
        System.out.println("成功完成改签。。");
    }
    @Override
    public void exitTicket() {
        System.out.println("成功退票。。。");
    }
}
  • 代理主题角色
package com.yc.Impl;

import com.yc.Interface.RailwayStation;
//代理类,也实现抽象主题角色,和委托对象有着相同的接口--》代理主题角色
public class RailwayStationImplProxy implements RailwayStation {
        RailwayStation rs;//获得抽象主题角色的引用 
        public  RailwayStationImplProxy(RailwayStation railwaySation) {
            this.rs=railwaySation;
        }//在构造方法中得到具体主题的实例。(为下文委托类调用方法埋下伏笔)
    @Override
    public void ByTicket() {
        docheck();//做身份验证处理,(额外的功能。原来买票时候可没有哦。)
        rs.ByTicket();//调用委托类的买票方法,所以说在使用代理类时,本质上还是用了具体主题类,也就是所说的,代售点的票还是火车站给的。
        dolog();//做点日志记录,(这和验证一样都是我们可以在代理类中新添加一些杂七杂八的东西)
    }

    @Override
    public void changeTicket() {
        docheck();
        rs.changeTicket();
        dolog();

    }

    @Override
    public void exitTicket() {
        docheck();
        rs.exitTicket();
        dolog();
    }

    //代理类额外添加的业务需求(核实身份,和记录购买记录)
    private void docheck() {
            System.out.println("已核实该用户身份,合法公民");    
    }

    private void dolog() {
        System.out.println("xxx已成功完成上述操作");

    }
}
  • 测试类
package com.yc.Test;

import org.junit.Test;

import com.yc.Impl.RailwayStationImpl;
import com.yc.Impl.RailwayStationImplProxy;
import com.yc.Interface.RailwayStation;

public class Customer {

    @Test
    public void testStatic() {
            RailwayStation rs1=new RailwayStationImplProxy(new RailwayStationImpl());   
            //传入具体主题角色,通过构造函数直接过得代理对象。
            rs1.ByTicket();
            rs1.changeTicket();
            rs1.exitTicket();
    }
}

测试结果:已核实该用户身份,合法公民
成功购买一张票
xxx已成功完成上述操作
已核实该用户身份,合法公民
成功完成改签。。
xxx已成功完成上述操作
已核实该用户身份,合法公民
成功退票。。。
xxx已成功完成上述操作

由结果可知:通过代理类我们不仅实现了我们的业务(订票,改签,买票),还额外的实现了对买票者身份的核实,以及买票的相关记录,而且这新添加的功能是在没有改动原主题角色类的情况下的,如果那天我们不想要这些额外功能了,就可以直接去了,完全不影响原来的业务逻辑的执行。(这也就是引入代理的很重要的原因)

总结一下静态代理的优缺点:
优点:1、代理类的.class文件在编译期就已经存在,所以执行速度很快。
2、隐藏了真实对象,不会修改真实对象的类代码

缺点:1、代理类的.class文件在编译期就已经存在,不够灵活(好尴尬,刚刚还是优点,尴尬人事变换莫测)
2、每一个具体主题角色都要配一个代理类,会造成类的膨胀(讲道理这样也是不合理的)
3、每一个方法都要配置我们额外的功能,造成了代码的冗余。

综合以上优比缺:2:3,所以我不得不再向你们介绍一下动态代理模式,来弥补静态代理的不足( 然后动态自己也有些不足,这就非常尴尬了)

动态代理(很重要,我就是看到spring-aop底层运行原理就是动态代理,所以才来了解代理模式的)
动态代理又可以分为两种
1.JDK实现动态代理;
2.Cglib实现动态代理;
我们还是先理解下什么是动态代理:从上次静态代理中我们可以看出,代理类在程序编译期就已经存在,而我们可以将该代理类的出现的时间放到程序运行时。也就是所编译时并不指定明确的代理类,而是在运行时要用到代理类时才去动态生成,这种在程序运行时动态生成代理的方式也就是动态代理。。。

1.jdk动态代理类:
正因为动态代理有这样灵活的特性,所以我们在设计动态代理类(DynamicProxy)时不用显式地让它实现与真实主题类(RealSubject)相同的接口(interface),而是把这种实现推迟到运行时。
为了能让DynamicProxy类能够在运行时才去实现RealSubject类已实现的一系列接口并执行接口中相关的方法操作,需要让 DynamicProxy类实现JDK自带的Java.lang.reflect.InvocationHandler接口,该接口中的invoke() 方法能够让DynamicProxy实例在运行时调用被代理类的“对外服务”,即调用被代理类需要对外实现的所有接口中的方法,也就是完成对真实方法的调 用,Java帮助文档中称这些真实方法为处理程序。
按照上面所述,我们肯定必须先把被代理类RealSubject已实现的所有interface都加载到JVM中,不然JVM怎么能够找到这些方法呢?明白了这个道理,那么我们就可以创建一个被代理类的实例,获得该实例的类加载器ClassLoader。
所谓的类加载器ClassLoader,就是具有某个类的类定义,即类的内部相关结构(包括继承树、方法区等等)。
更重要的是,动态代理模式可以使得我们在不改变原来已有的代码结构的情况下,对原来的“真实方法”进行扩展、增强其功能,并且可以达到控制被代理对 象的行为的目的。请详看下面代码中的DynamicProxy类,其中必须实现的invoke()方法在调用被代理类的真实方法的前后都可进行一定的特殊 操作。这是动态代理最明显的优点

类图如下:这里写图片描述

代码实现:(还是之前得需求)

package com.yc.Impl;

import java.lang.annotation.Target;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynamicProxy implements InvocationHandler{

    private Object targetObj;

    public  Object newInstanceProxy(Object targetObj){
        this.targetObj=targetObj;
        // 第一个参数,目标对象的类加载器(就是具有某个类的类定义,即类的内部相关结构(包括继承树、方法区等等)。)
        // 第二个参数,目标接口已实现的所有接口,而这些是动态代理类要实现的接口列表
        // 第三个参数, 调用实现了InvocationHandler的对象生成动态代理实例,当你一调用代理,代理就会调用InvocationHandler的invoke
        return Proxy.newProxyInstance(targetObj.getClass().getClassLoader(),targetObj.getClass().getInterfaces(),this); 
    }   

    //当调用代理实例中的方法时,就会自动执行下面的invoke方法,传入的是我们要执行的方法和参数
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
            Object result=null;
            docheck();//额外添加的方法
            result=method.invoke(targetObj, args);//执行具体主题角色类的中的方法
            dolog();//额外添加的方法
            return result;//返回执行方法的结果。。

    }

    //代理类额外添加的业务需求(核实身份,和记录购买记录)
    private void docheck() {
            System.out.println("已核实该用户身份,合法公民");    
    }

    private void dolog() {
        System.out.println("xxx已成功完成上述操作");
    }       
}

测试类:

    @Test
    public void testDynamic() { 
            DynamicProxy dp=new DynamicProxy();//不要误会这个可不是代理类的实例

            RailwayStation rs2=(RailwayStation)  dp.newInstanceProxy(new RailwayStationImpl());
            //rs2这个才是对应RailwanStationimpl类的代理实例
            rs2.ByTicket();//调用代理实例时会执行invoke方法,实现我们的所有需求
            rs2.changeTicket();
            rs2.exitTicket();
    }

看了动态代理发现是不是神奇了很多,简单总结一下他的优缺点;
优点:1、代理实例在程序运行时才会产生,让程序更为灵活。
2、通过实现InvocationHandler接口,每次调用代理时都会自动运行其中的invoke 方法,然后根据调用的方法找到真实对象中的方法,不需要每个方法都写一次,避免了代码的冗余。
3、很明显这里可个类可以创建很多个真实类的代理实例,所以避免了类的膨胀
缺点:1、相比于静态代理,动态代理是在运行时才生成,所以在整个运行时,速度较慢。
2、只能对实现接口的类进行代理

所以静态代理和动态代理各有各的优点,各有各的缺点,具体使用哪一种要根据程序自身的需求来判断

2.Cglib实现动态代理;

AOP的源码中用到了两种动态代理来实现拦截切入功能:jdk动态代理和cglib动态代理。
两种方法同时存在,各有优劣。jdk动态代理是由java内部的反射机制来实现的 ,cglib动态代理底层则是借助asm来实现的。总的来说,反射机制在生成类的过程中比较高效,而asm在生成类之后的相关执行过程中比较高效(可以通 过将asm生成的类进行缓存,这样解决asm生成类过程低效问题)。还有一点必须注意:jdk动态代理的应用前提,必须是目标类基于统一的接口。如果没有 上述前提,jdk动态代理不能应用。由此可以看出,jdk动态代理有一定的局限性,cglib这种第三方类库实现的动态代理应用更加广泛, 且在效率上更有优势。
JDK的动态代理机制只能代理实现了接口的类,否则不能实现JDK的动态代理,cglib是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强,但因为采用的是继承,所以不能对final修饰的类进行代理。

介绍:
CGLIB的核心类:
net.sf.cglib.proxy.Enhancer – 主要的增强类
net.sf.cglib.proxy.MethodInterceptor – 主要的方法拦截类,它是Callback接口的子接口,需要用户实现
net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method类的代理类,可以方便的实现对源对象方法的调用,如使用:
Object o = methodProxy.invokeSuper(proxy, args);//虽然第一个参数是被代理对象,也不会出现死循环的问题。
net.sf.cglib.proxy.MethodInterceptor接口是最通用的回调(callback)类型,它经常被基于代理的AOP用来实现拦截(intercept)方法的调用。这个接口只定义了一个方法
public Object intercept(Object object, java.lang.reflect.Method method,
Object[] args, MethodProxy proxy) throws Throwable;
第一个参数是代理对像,第二和第三个参数分别是拦截的方法和方法的参数。原来的方法可能通过使用java.lang.reflect.Method 对象的一般反射调用,或者使用 net.sf.cglib.proxy.MethodProxy对象调用。net.sf.cglib.proxy.MethodProxy通常被首选使 用,因为它更快

package com.yc.Impl;

import java.lang.annotation.Target;
import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibDynaproxy implements MethodInterceptor {

        private Object targetObj;

        public Object proxynewInstance(Object targetObj){//获取代理对象实例

            this.targetObj=targetObj;

            Enhancer enhancer=new Enhancer();// 用这个类来创建代理对象(被代理类的子类):

            enhancer.setSuperclass(targetObj.getClass());//设置父类,也就是我们的目标类,使我们的代理类成为主题类的子类

            enhancer.setCallback(this);//设置回调函数,当程序调用代理中的方法是,就会自动执行下面的intercept方法

            enhancer.create();//到此完成对代理实例的创建

            return enhancer;

        }
    @Override
    public Object intercept(Object obj, Method method, Object[] args,
            MethodProxy methodProxy) throws Throwable {
           Object result = null;
           docheck();//额外添加身份核实功能
            result=methodProxy.invokeSuper(obj, args); //调用新生成的cglib的代理对象 所属的"父类"的被代理的方法
            dolog();//额外添加日志功能
            return result;

    }

    //代理类额外添加的业务需求(核实身份,和记录购买记录)
        private void docheck() {
                System.out.println("已核实该用户身份,合法公民");    
        }

        private void dolog() {
            System.out.println("xxx已成功完成上述操作");
        } 
}

测试类: @Test
public void testCglibDynamic() {

    CglibDynaproxy cdp=new CglibDynaproxy();
    RailwayStationImpl rs3=  (RailwayStationImpl) cdp.proxynewInstance(new RailwayStationImpl());//可以直接使用具体主题类,不在需要接口
        rs3.ByTicket();
        rs3.changeTicket();
        rs3.exitTicket();
}
运行结果:同上。

差不多代理模式介绍就这样了。剩下的就是看大家如何灵活的去用代理模式了。

参考文章:http://blog.youkuaiyun.com/tanggao1314/article/details/51001272(哈哈,参考的有点多,感觉和转载都差不多了,。。)

【STM32G474实战】RS485通信的DMA优化策略与性能对比 本文深入探讨了在STM32G474微控制器上优化RS485通信的DMA策略。通过对比轮询、中断和DMA三种数据传输方式的代码实现与性能,揭示了DMA在解放CPU、降低占用率方面的巨大优势。文章提供了详细的DMA配置指南、高级应用技巧(如结合空闲中断)以及一个高可靠通信框架的实战思路,旨在帮助开发者构建高效、实时的工业控制系统。 阅读详情

相关推荐

FPGA实战:手把手教你用Verilog驱动4.3寸RGB触摸屏(附完整代码)

本文详细介绍了如何使用Verilog语言在FPGA上驱动4.3寸RGB触摸屏,包括时序设计、信号交互原理及完整代码实现。通过双计数器引擎设计和参数化模块,开发者可以高效构建800*480分辨率的显示驱动,并解决工程实践中的信号完整性和时序收敛问题。

rice5的博客 706

JDK8动态代理示例与原码解析

1. 原理,代理模式 代理模式的本质:调用方--->代理方--->实现方。 相对于:调用方--->实现方,降低了调用方与实现方的藕联性,由代理方对实现进行包装,可以包装多个实现方。 1.1 代理模式分为静态代理和动态代理。 其中静态代理需要在代码编写时,编译期提供具体的实现类,不能在程序运行时动态变化代理实现。 其中动态代理常用于Spring的AOP中,有JDK动态代理...

fenglllle的博客 1212

Windows BITS服务:后台智能文件传输技术详解

后台文件传输技术是现代IT基础设施中的关键组件,Windows BITS(Background Intelligent Transfer Service)作为微软原生解决方案,通过队列管理和智能调度实现高效数据传输。其核心技术原理包括分块传输、断点续传和带宽自适应,能够根据网络状况动态调整传输速率(默认占用空闲带宽的80%)。在工程实践中,BITS特别适用于企业软件分发和自动化数据采集场景,通过PowerShell命令即可实现高优先级传输和代理配置。相比传统FTP方案,BITS在跨国文件传输中将失败率从30

weixin_42116058的博客 288

java 代理模式 讲的比较详细,转载过来,以后忘记了还可以看

简介 Java编程的目标是实现现实不能完成的,优化现实能够完成的,是一种虚拟技术。生活中的方方面面都可以虚拟到代码中。代理模式所讲的就是现实生活中的这么一个概念:中介。 代理模式的定义:给某一个对象提供一个代理,并由代理对象控制对原对象的引用。 代理模式包含如下角色: ISubject:抽象主题角色,是一个接口。该接口是对象和它的代理共用的接口。 RealSubjec

金色年华 688

【Python 实战基础】如何绘制热力图来模拟绘制北京景区热度图

Python如何绘制热力图来模拟绘制北京景区热度图 文件读写 基础语法 字符串处理 文件生成 数据构建

菜鸟实战的博客 3403

RPG MV游戏数据修改指南:从JSON解析到脚本进阶

游戏数据修改是游戏开发与逆向工程中的常见实践,其核心原理在于解析和操作游戏资源文件。许多现代游戏引擎采用结构化数据格式(如JSON)存储游戏配置,这为外部修改提供了可能。通过理解文件结构、数据格式与游戏逻辑的关联,开发者或爱好者可以调整游戏平衡、修复问题或实现个性化定制,这不仅能深化对游戏设计机制的理解,也具备实际的技术学习价值。本文以基于Web技术栈的RPG Maker MV(RPG MV)引擎为例,其游戏数据多以明文JSON存储,结构清晰。文章将具体阐述如何安全地修改角色属性、物品效果、敌人数据及技能公

weixin_29001419的博客 408

动态代理

动态代理 在程序运行时,创建代理类的代理方式被称为动态代理 分类: jdk动态代理是利用java反射机制(java.lang.reflect包) cglib动态代理底层则是借助asm来实现的 好处: 在不改变程序源码的基础上,对代码进行增强或者屏蔽 动态代理的前提:必须有接口 JDK动态代理 原理 入门 接口 public interface Sing { ...

Jesson_study 256

ubuntu虚拟机搭建OP-TEE

在网上找了一些搭建OP-TEE的过程,模仿着进行搭建,结果有好多报错,为了方便自己以后重新搭建,所以将整个过程记录下来。

weixin_44213847的博客 1004

java8动态代理

/** * @Author lyr * @create 2020/3/29 12:04 */ public interface Axe { void chop(); } /** * @Author lyr * @create 2020/3/29 12:04 */ public class StealAxe implements Axe { @Override ...

LYR 的博客 348

深入解析AMBA5 AXI与ACE协议:从基础到高级应用

本文深入解析了AMBA5 AXI与ACE协议的核心机制与应用。AXI协议通过分离通道、突发传输和乱序完成实现高性能数据传输,而ACE协议在此基础上构建了硬件级缓存一致性解决方案,通过监听机制和状态模型确保多核系统数据统一。文章还探讨了在异构计算等复杂场景下的实战应用与AMBA5的新特性。

cc789的博客 964

自定义载板RK3588HDMI输入配置完整解决方案

✅ HDMI输入信号检测✅ 自动时序识别(支持1080p@60Hz等标准格式)✅ V4L2视频设备接口✅ 实时视频流捕获✅ H.264编码录制✅ HDCP内容保护支持问题根因识别:发现了hdmim1模块资源冲突的本质问题硬件设计理解:明确了Orange Pi 5 Plus的真实硬件设计意图功能实现:成功启用HDMI输入功能,替代了无法使用的HDMI1输出完整验证:建立了从硬件检测到视频录制的完整测试流程。

梁俊星的博客 1273

java8 静态代理,jdk动态代理

首先说下静态代理,接口 -> 实现-> 代理, 实现与代理有相同的接口。代理执行时会将实现作为参数传入,代理执行的方法其实是实现的方法,并且可以在执行此方法前后添加其它功能。 代码: /** * 静态代理 * Create on 2018/8/7 by wangyubing */ public class Main { public static void mai...

qq_39765090的博客 388

芒果YOLOv10改进31:特征融合Neck篇:改进特征融合网络 BiFPN 结构,融合更多有效特征

YOLOv10改进:特征融合Neck篇:改进特征融合网络 BiFPN 结构,融合更多有效特征

包括YOLOv5、YOLOv7、YOLOv8等模型改进 686

JAVA【接口】【代理模式】【工厂设计模式】【JAVA8部分特性】【内部类的使用】

7.接口和接口之间可以继承,而且可以多继承,在下面的代码中CC就成功继承了AA,BB,所以我们的bullet在调用CC接口的时候,需要把AA和BB中定义的方法全部去实现。最后我们在调用的时候,我们首先创建了一个真实的被代理类,然后创建一个代理,将我们被代理的对象传递给代理,紧接着就让代理帮助我们完成了网络连接的工作。简单工厂模式的特点,就是首先将如何创建每一种车的方式写好,然后将我们不同的造车方式告诉我们的工厂,然后我们的工厂会随着我们调用的需要去建造不同的车。抽象工厂模式用来生产不同产品族的全部产品。..

芊樱烛渊的博客 423

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

Java设计模式——代理模式实现及原理(基于java8)

简介 Java编程的目标是实现现实不能完成的,优化现实能够完成的,是一种虚拟技术。生活中的方方面面都可以虚拟到代码中。代理模式所讲的就是现实生活中的这么一个概念:中介。 代理模式的定义:给某一个对象提供一个代理,并由代理对象控制对原对象的引用。 代理模式包含如下角色: ISubject:抽象主题角色,是一个接口。该接口是对象和它的代理共用的接口。 RealSubjec

将来的你一定会感谢现在努力的自己 1366

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

Java二十三种设计模式-代理模式(8/23)

代理模式是一种结构型设计模式,其核心思想是为一个对象提供一种代理,以控制对这个对象的访问。代理模式可以在不修改目标对象的基础上,通过引入一个代理层来间接操作实际对象,从而实现对目标对象的访问控制、延迟初始化、日志记录、权限校验等功能。定义:定义了真实对象和代理对象的共同接口,这样代理可以代替真实对象被使用。角色:充当代理和真实对象的契约。代理模式提供了一种灵活的方式来控制对对象的访问,同时允许在不修改对象自身的情况下添加额外的职责。

小相探索IT世界 2043

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

Java 之 23 种设计模式解析——8、代理模式(Proxy)

8、代理模式(Proxy) 其实每个模式名称就表明了该模式的作用,代理模式就是多一个代理类出来,替原对象进行一些操作,比如我们在租房子的时候回去找中介,为什么呢?因为你对该地区房屋的信息掌握的不够全面,希望找一个更熟悉的人去帮你做,此处的代理就是这个意思。再如我们有的时候打官司,我们需要请律师,因为律师在法律方面有专长,可以替我们进行操作,表达我们的想法。先来看看关系图:   根据上文的...

毕富国的博客 673

java设计模式之代理模式(8)

代理模式就是,不直接调用目标函数,而是通过一个代理类来调用。 它的类继承关系和装饰模式很类似。但是它们的目的不一样。 代理模式不会增加新的功能,只是在调用和被调用之间加入代理层。而装饰模式旨在增加新功能。 看代码: package com.pattern.struct.proxy; public interface Subject { public void request();

貌似君子的专栏 1084

java设计模式8——代理模式(Proxy)

其实每个模式名称就表明了该模式的作用,代理模式就是多一个代理类出来,替原对象进行一些操作,比如我们在租房子的时候回去找中介,为什么呢?因为你对该地区房屋的信息掌握的不够全面,希望找一个更熟悉的人去帮你做,此处的代理就是这个意思。再如我们有的时候打官司,我们需要请律师,因为律师在法律方面有专长,可以替我们进行操作,表达我们的想法。先来看看关系图: 根据上文的阐述,代理模式就比较容易的理

忆、瞻的专栏 966

java 设计模式_结构型_8代理模式——静态代理

摘要: 代理模式通过代理对象间接访问目标对象,在不修改原代码的基础上扩展功能(如明星通过经纪人处理事务)。静态代理需代理类与目标类实现相同接口(如IUserDao),代理类(UserDaoProxy)增强目标类(UserDao)的方法调用(如添加事务处理)。优点是可扩展目标功能,缺点是接口变动时需同步修改代理类,且易产生过多代理类。动态代理可解决此问题。 (字数:150)

qq_39275653的博客 351

Java设计模式(8)结构型:代理模式

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.youkuaiyun.com/zeping891103/article/details/53842154 (一)模式概述 代理模式指为其他对象提供一种代理方式以控制对某个对象的访问。在某些情况下,一个...

chongfeng2994的博客 82

Java设计模式(8)之代理模式

代理模式: 为真实对象提供一种代理以便控制对这个真实的访问。使用代理对象完成用户请求,屏蔽用户对真实对象的访问。 类型: 结构型模式 代理模式的角色: 源接口(Component):定义代理类和被代理类的公共对外方法。 被代理类/真实对象(Source):只有代理对象才能访问。 代理类(Proxy):访问真实对象。 客户端(ProxyTest):客户端访问真实对象前,需要进行权...

innerpeacez成长之路 312

(8)Java设计模式 - 代理模式(Proxy Pattern)

介绍 代理模式(Proxy Pattern)也叫做委托模式,为其他对象提供一种代理以控制对这个对象的访问。 结构  通用类图如下: 代理模式包含如下角色: Subject(抽象主题):可以是接口,也可以是抽象类。 RealSubject(真实主题):业务逻辑的具体执行者。 ProxySubject(代理主题):内部含有RealSubject的引用,负责对真实角色的调用,并在真实主...

潘建南的博客 1602

JAVA设计模式(8)结构型-代理模式

代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能. 1、静态代理 /** * 接口 * author: V : jbossjf */ public interface IUserDao { void save(); } /** * 接口实现 * 目标对象 */ public class UserDao implements IUserDao {

长春小佛爷的博客 119

java 设计模式_结构型_8代理模式——动态代理

摘要: 本文介绍了两种代理模式:动态代理和Cglib代理。动态代理通过JDK的Proxy类在内存中构建代理对象,无需实现接口,只需指定目标对象的接口类型和事件处理器。Cglib代理则针对未实现接口的目标对象,通过生成子类实现代理扩展功能,适用于final/static方法的场景。两种代理均通过工厂模式生成代理对象,并在方法调用前后添加事务处理逻辑。测试代码展示了代理对象的使用方式及其与目标对象的交互过程。

qq_39275653的博客 987

【源码分析设计模式 8】mybatis中的代理模式,java技术点分享

@Override public void play() { advertising(true); movie.play(); advertising(false); } private void advertising(boolean isBoforMovie){ if(isBoforMovie){ System.out.println(“影片马上开始,素小暖入驻优快云啦,快来关注我啊”); }else{ System.out.println(“影片正片已经结束,马上彩蛋环节,不要离开哦,素小暖入驻CS

m0_64384202的博客 487
上一篇: form表单提交方式,js/jquey/easyui
下一篇: 深入理解java虚拟机(1)-java内存区域
黄小小州
博客等级 码龄10年 16粉丝 18原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值