Java 手写 Spring框架 IOC 和 AOP----手写Spring IoC和AOP

简易手写实现Spring框架中的IOC和AOP事务管理 本文还有配套的精品资源,点击获取 简介:在Java开发中,使用控制反转(IOC)和面向切面编程(AOP)可以显著提升代码的可维护性和扩展性。本示例将通过工厂模式和动态代理技术,从零开始实现IOC和AOP,特别是事务管理功能。我们将创建接口和实现类,通过工厂模式管理对象生命周期,并利用动态代理实现事务的自动处理,从而实现关注点的分离。这个实践案例有助于深入理解Spring框架... 阅读详情
源码(码云):https://gitee.com/yin_zhipeng/implement-_spring_of_myself.git

本文源码基于5.1.12版本讲解:Spring的源代码设计精妙、结构清晰、匠心独用、处处体现大师风范,对Java设计模式的灵活运用,对Java技术的高深造诣,无疑是Java技术的最佳实践范例
  1. 另外,IoC和AOP两种思想,不是Spring提出,在Spring之前就提出了,只不过更偏向于理论化,而Spring在技术层次,把两个思想用Java语言做了非常好的实现

一、Spring 概念复习

这里快速过一下Spring基本概念 ,免得手写源码和看源码的时候,有些东西忘了(会觉得不明所以),而且也是面试官经常会问的一些问题

1. 基本概念

什么是Spring 框架(Spring Framework)
  1. 分层(Controller,Service,Mapper)的full-stack(全栈)轻量级开源框架(发展越来越好,已经可以提供全套的功能支持)
  2. 以IoC和AOP为内核,提供展现层Spring MVC和业务层事务管理等众多企业级应用技术(Spring可以用在各层提供服务)
  3. 可以整合开源世界众多著名的第三方框架和类库,已经是使用最多的Java EE企业应用开源框架(站在巨人的肩膀上,提供整合接口,可以整合其它很多优秀框架)
Spring 框架的优势
  1. 方便解耦合,简化开发
  1. 通过IoC容器,可以将对象间依赖关系交由Spring进行控制,避免硬编码所造成的过度程序耦合。用户也不必再为单例设计模式类、属性文件解析等这些很底层的需求编写代码,可以更注重与上层的应用实现。
  1. AOP编程的支持
  1. 方便进行面向切面的编程,许多用传统OOP不容易实现的功能,可以通过AOP轻松应付
  1. 声明式事务的支持(事务和业务代码没有耦合到一块)
  1. 一般我们只需要方法上加个@Transactional注解就可以将我们从单调烦闷的事务管理代码中解脱出来,通过声明式的方式灵活的进行事务的控制,提高开发效率和质量
  1. 方便程序的测试
  1. 可以用非容器依赖的编程方式进行几乎所有的测试工作,测试不再是昂贵的操作,随手就可以做
  1. 方便继承各种优秀框架
  1. Spring 可以降低各种框架使用难度,提供了对各种优秀框架的直接支持(Struts、Hibernate、Hessian、Quartz等等)
  1. 降低JavaEE API的使用难度
  1. Spring对JavaEE API(例如JDBC、JavaMail、远程调用等)进行了薄薄的封装层,使这些API的使用难度大为降低。
Spring核心结构
  1. Spring是一个分层非常清晰并且依赖关系、职责定位非常明确的轻量级框架,主要包括数据处理、Web、AOP/Aspects、Core Container、Test模块
  2. Spring依靠这些基本模块,实现了一个令人愉悦的融合了现有解决方案的零入侵的人轻量级框架,并且模块化的思想,我们需要什么模块,引用什么就可以了,一个模块包含多个jar包,如下图:
    在这里插入图片描述

2. IoC编程思想和DI

什么是IoC(Inversion of Control/控制反转/反转控制)
  1. IoC是一个思想,不是技术实现,IoC思想下,是将对象,统一交给IoC容器管理
  2. 我们不需要考虑对象的创建、销毁等管理问题,这些全部交给IoC容器去做
  3. IoC容器会帮我们实例化对象并管理它们,我们要用,就去和IoC容器要
控制反转
  1. 控制:指对象的创建(实例化,管理)的权利
  2. 反转:控制权交给外部环境(Spring框架、IoC容器)
为什么可以帮助我们解决类与类之间的耦合
  1. 一般我们Service(逻辑业务层)会使用dao(持久层)的功能,如果我们使用传统new对象的话,我们就需要和具体实现类耦合(一般我们都使用接口,但是new对象,需要用具体实现类)
//假设我们有一开始的实现类是UserDaoImpl
UserDao userDao = new UserDaoImpl();
//当我们想要将实现类换为UserDaoInplNew,那么所有Service层的代码都需要修改
UserDao userDao = new UserDaoInplNew();
  1. 但使用Spring,我们只需要接口,不需要在Service层new实现类,此时无论我们怎么变换接口的实现类,都不需要修改Service层代码
@Autowired
private UserDao userDao;
DI(Dependancy Injection依赖注入)
  1. 和IoC描述的是同一件事情,但是角度不一样
  2. IoC站在对象的角度,对象实例化及管理权利交(反转)给了容器
  3. DI站在容器的角度,会把对象依赖的其它对象注入,比如IoC容器中有A类和B类。A类依赖B类,那么我们实例化A类的时候,需要将B类对象注入给A对象
什么是依赖
  1. 假设有A类和B类,A类中有这样一段代码B b = new B();
  2. 那么我们说A类依赖B类

3. AOP编程思想

传统OOP(面向对象)利用封装继承多态,可以解决大部分代码重复问题,一种垂直纵向的继承体系
  1. 下图中,每个动物都有吃和跑方法,那么就可以让他们继承公共父类Animal,而不用每个动物都写重复代码
    在这里插入图片描述
AOP(Aspect oriented Programming/面向切面编程/面向方面编程):是OOP的延续,解决OOP解决不了的问题
  1. 假设我们要在每个方法执行前后做一些额外操作,比如记录每个动物,什么时候开始吃,什么时候吃完,什么时候开始跑,什么时候跑完
  2. 那么我们就需要在每个方法(eat()和run())的逻辑代码前后添加额外的代码,并且这些代码是重复的,当然我们要避免这种情况,这时就可以使用切面编程,下图中,可以看出,不使用切面编程,有很多重复代码
    在这里插入图片描述
  3. 当然我们可以使用动态代理设计模式,而AOP就是动态代理的实现
    在这里插入图片描述
  4. 上图中,可以发现,我们将每个方法(假设有100个方法)前后执行的额外动作,抽离出去,然后向一把刀一样,对着每个方法的两个点(一堆点,就组成了一个面),切了上去,就像一个切面,所以我们叫面向切面编程
  5. 这样呢,我们将横切代码,和业务逻辑代码分开了(解耦合),而且,我们不用每个方法中都写横切代码,只需要写一份
  6. 可以理解为,原来我们将横切代码做成点,在每一个方法进行横切,而AOP,是直接做成一把刀,一刀下去所有点都一起切了
AOP解决的问题
  1. 不改变原有业务逻辑的情况下,增强功能(横切逻辑代码),根本上解耦合,避免横切逻辑代码重复

二、手写IoC容器

实例化对象问题,使用反射解决
  1. 为了避免使用接口,new实现类这种耦合问题,我们需要换一种实例化对象的方式
  2. 除了new关键字实例化对象以外,我们还可以通过反射来获取对象实例
  3. 只需要提供这个类的全限定类名(完整的类名例如:java.lang.String)然后通过Class.forName(“全限定类名”);就可以拿到这个类的对象
  4. 但是这又有新的耦合问题,全限定类名如果写到类中,就会耦合,日后我们想要改,又得去改所有用到的类
  5. 所以我们可以让它和类解耦合,将全限定类名配置到xml文件中
思路有了,用什么方法实例化对象呢?我们可以参考设计模式,例如工厂模式
  1. 使用工厂设计模式,通过反射技术生产对象
  2. 工厂模式是解耦合的一种非常好用的方式

1. 通过xml文件配置bean实例

假设我们有如下类结构

在这里插入图片描述

为了解耦合,我们将实例对象都配置到xml文件中
  1. 我们实例化的是特定的实现类 的全限定类名 class
  2. 我们要给每一个实例配置一个唯一标识 id
    在这里插入图片描述

2. 通过工厂生产实例

思路
  1. 读取xml文件,根据class全限定类名,反射实例化对象,然后以id为key,以实例化对象为value,存储到map中
  2. 对外提供获取实例对象的接口(根据id)
为了方便起见,我们使用dom4j工具类,解析xml文件,例如Jaxen提供的XPath表达式,方便我们操作解析好的xml文档对象(可以快速检索我们需要的东西),引入相关maven依赖

在这里插入图片描述

XPath表达式,通过路径表达式来选取XML文档中的节点或节点集
    /**
     * 常用表达式
     * nodename 选取此节点的所有子节点
     * /        从根结点选取
     * //       从当前匹配的节点选取,会选取当前节点下的所有匹配的子节点(不考虑层级,包括孙子节点)
     * *        选取所有
     * **       选取当前结点的父节点
     * @        选取属性
     */
工厂类

在这里插入图片描述
在这里插入图片描述

此时我们Service层想用dao层对象,就不用new实现类了

在这里插入图片描述

问题
  1. 虽然不用new实现类了,但是我们把工厂写死到代码里面了,也有一定程度的耦合
  2. 理想的状态应该是
private AccountDao accountDao;
  1. 那实例对象从哪来呢,我们可以通过set方法来设置
    在这里插入图片描述
那么我们该如何做呢?
  1. xml中给bean实例配置属性,我们根据属性值AccountDao,调用setAccountDao方法,传入的参数用ref来指定(反射好的AccountDaoImpl映射,就是上面配置的内个)
    在这里插入图片描述
  2. 工厂实例化对象完成后,维护对象依赖关系,根据属性将其注入
    在这里插入图片描述
测试一下效果
  1. 给两个接口提供test()方法,两个实现类进行实现
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
  2. 写个测试类测试
    在这里插入图片描述
    在这里插入图片描述

三、手写AOP

一般我们会用AOP来处理事务问题,假设我们有A用户和B用户,两人分别有10元
  1. 当用户a给用户b转账5元后,程序正常情况下,最终A有5元,B有15元
  2. 但是如果用户a转账5元后,程序出错,将前转给B的代码没有运行,最终就会发生用户A失去了5元,但是用户B没有收到钱的情况
    在这里插入图片描述
  3. 如果换一下,B先+5元,然后A再-5元,那么程序出错后,B有15元,但是A没有-5元,依然有10元,这样银行就亏钱了
  4. 那么我们希望什么结果呢?
  1. 当程序出错后,及时回滚,
  2. 假设a-5后,程序报错,我们要立即回滚,让a的余额重新变为10,然后通知转账失败
如果将上面的操作,都换成JDBC操作数据库(两次查询,两次修改,一共4次数据库(JDBC)操作),那么会有如下问题
  1. 首先数据库事务,其实是Connection(连接)的事务,默认是自动提交事务
connection.setAutoCommit(false);//设置为不自动提交
connection.commit();//提交事务
connection.rollback();//回滚事务
  1. 那么两次update使用两个数据库连接Connection,这样的话,肯定不属于同一个事务控制
  2. 而且事务控制我们要统一放到service层控制(一个service可能涉及到很多dao层操作)
解决方案
  1. 两次update使用同一个connection连接
  1. 首先,一个请求过来肯定在一个线程中执行,无论多少次update,都在这个线程中,所以将connection和当前线程绑定,当前线程有关系的数据库操作都使用这个Connection
  1. 把事务控制添加在service层

1. 使用JDBC操作数据库模拟银行转账,解决事务问题

1. 创建数据库和实体类,引入相关依赖

数据库

在这里插入图片描述

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for account
-- ----------------------------
DROP TABLE IF EXISTS `account`;
CREATE TABLE `account`  (
  `id` char(20) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL,
  `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL,
  `money` int(20) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_bin ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of account
-- ----------------------------
INSERT INTO `account` VALUES ('1', 'A', 10);
INSERT INTO `account` VALUES ('2', 'B', 10);

SET FOREIGN_KEY_CHECKS = 1;
对应实体类

在这里插入图片描述

引入相关依赖

在这里插入图片描述

2. 将连接与当前线程绑定,多个JDBC操作使用同一个连接

Druid数据库连接池工具类,懒汉式单例

在这里插入图片描述

将连接绑定到当前线程的工具类,单例模式,否则每次都new一个对象,依然不是同一个connection连接

在这里插入图片描述

编写dao层,提供对数据库的操作

在这里插入图片描述
在这里插入图片描述

此时,一个线程,多个JDBC操作都使用同一个连接,我们编写service层。进行测试

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3. service层添加事务控制

上面已经实现了一个线程绑定一个连接,用一个连接执行多个JDBC操作,现在就可以编写事务了
  1. 如果JDBC操作使用不同连接,这些操作不在一个事务中,是没办法控制的
  2. 想要事务控制,就必须实现共用一个连接
接下来,我们将一步步的升级,从普通事务处理,到动态代理,到AOP
为transfer转账方法添加事务代码

在这里插入图片描述

2. 面向切面,事务管理

上面解决了事务问题,但是现在每个方法,都需要写相同的事务代码,接下来将其解耦

1. TransactionManager事务管理器

我们将事务代码单独写到事务管理器

在这里插入图片描述

service层使用

在这里插入图片描述

这种办法很笨,如果有100个方法,就需要这样写100次,而且也依旧存在业务代码和事务代码耦合的问题。虽然改事务,直接去事务管理器改就行,但是如果我们要换个事务管理器,又得每个方法都改

2. 动态代理改造

代理设计模式可以参考这篇文章,详细介绍了静态代理和动态代理:https://blog.youkuaiyun.com/grd_java/article/details/109690730
为什么选用动态代理
  1. 静态代理,是针对特定的一件事代理,比如你是租房中介代理,那么你需要单独的一个代理类处理租房这件事,租车代理,又需要单独写租车代理
  2. 显然,使用spring的千千万,没办法为每一件事都写一个静态代理类,有办法,也太多了
  3. 动态代理,由反射实现,不需要为每一个事件,都写一个代理类,它可以动态的为很多事进行代理,也就是根据委托对象的不同,生成不同的代理人
动态代理,Java有两种主流实现方式,一种是JDK原生动态代理,一种是利用第三方jar包CGLIB实现动态代理
  1. 我们做一个代理工厂,根据我们的需要,选择不同的代理
  2. 通过JDK(需要提供接口)或CGLIB(不需要接口)生产代理对象
  3. CGLIB需要引入额外jar包
    在这里插入图片描述
代理工厂:生成不同种类的代理,例如JDK原生,或者Cglib

在这里插入图片描述
在这里插入图片描述

接下来,service层就不需要任何事务横切代码了

在这里插入图片描述

使用动态代理对象,处理事务

在这里插入图片描述
在这里插入图片描述

当然,你可以更粗暴一点,service层异常代码统统可以不要

在这里插入图片描述

3. 交给IoC管理

我们的AOP实现,全部使用new对象的方式,耦合严重,我们需要将其解耦合
  1. 配置beans.xml
    在这里插入图片描述
  2. ConnectionUtils类,有IoC管理,我们不用自己实现单例设计模式了
    在这里插入图片描述
  3. TransactionManager,不用自己实现单例,并且依赖ConnectionUtils,解耦合,让IoC依赖注入,不new对象
    在这里插入图片描述
  4. ProxyFactory,不自己实现单例,不new对象,让IoC帮忙注入
    在这里插入图片描述
  5. 使用代理工厂时(AOP),和IoC要
    在这里插入图片描述

四、定义@Service、@AutoWired、@Transaction注解类

来回写代码,不如一个注解直接解决来的香,接下来完成基于注解的IOC容器(Bean对象创建及依赖注入维护)和声明式事务控制
  1. 我们要考虑注解有无value属性值(例如@Service(value=""))
  2. 添加事务时,service层是否有接口,选择使用JDK还是CGLIB版本的代理对象
@TODO 日后更新

五、高级使用和源码

由于篇幅限制,我将其放在这篇文章:https://blog.youkuaiyun.com/grd_java/article/details/122647693
大模型安全-生成检测-事实核查-攻击-防御-思考-记忆-融合-语音相关研究 2025年版 本文整理了关于大模型安全领域的综合性资源,包括7篇综述论文、9个安全数据集以及5篇强化学习相关的安全研究论文。主要涉及大模型的对抗攻击、隐私保护、安全评估等方向,涵盖TruthfulQA、ToxiGen等知名数据集和TrustLLM、HarmBench等关键研究。资源包括知乎博主分享、arXiv预印本和顶会论文,并附有详细的中文讲解链接,为研究者提供了系统性的安全研究参考。 阅读详情

相关推荐

MTK MT6833平台屏幕与TP驱动移植实战:从FAE伪代码到内核模块集成

本文详细介绍了在MTK MT6833平台上进行屏幕与TP驱动移植的完整实战流程。文章从解析供应商提供的初始化伪代码入手,逐步拆解了在LK阶段点亮屏幕、在内核层集成Panel驱动以支持休眠唤醒,以及移植并调试sitronix_ts触摸驱动的核心步骤与关键技巧,为嵌入式开发人员提供了从零到一集成新硬件的清晰指南。

rnn9storyteller的博客 441

手写springIOC、AOP

手写springIOC、AOP

qq_35080214的博客 2551

避开这些坑!QMT多因子策略实盘中的5个常见错误及解决方案

本文深入剖析了在QMT平台上实施多因子策略时常见的5个错误,包括因子过拟合、数据延迟处理不当、因子失效、交易成本低估和风险控制缺失,并提供了实用的解决方案。通过优化因子筛选、数据对齐和动态管理,帮助量化交易者提升策略稳健性和实盘表现。

k5l6m的博客 238

手写IOC及AOP

Spring手写ioc&aop

zw815210201的博客 1万+

手把手教你解决COLMAP编译中的Ceres CUDA支持问题(附详细配置步骤)

本文详细解析了COLMAP编译中Ceres CUDA支持问题的完整解决方案,包括环境准备、Ceres Solver的CUDA编译配置、COLMAP的CUDA集成配置等关键步骤。通过优化CMake参数和解决常见错误,帮助技术人员充分利用GPU加速优势,提升三维重建效率。

vodka的博客 858

从零开始深入理解 AI Agent(完整版)

AI Agent(智能体)是一个能够自主感知环境、做出决策、执行行动并记忆经验的智能系统。特性传统程序AI Agent决策方式固定逻辑(if-else)动态推理(LLM 思考)灵活性需要重新编程自然语言描述即可能力边界明确限定可通过工具扩展学习能力无可通过记忆积累经验│ 感知 │ ───→ │ 推理 │ ───→ │ 行动 │↑ │ ││ ↓ ││ 记忆 │ ←─── │ 反思 │ ←─────────┘感知(Perception)

qq_20096229的博客 754

手写简易AOP,彻底悟懂AOP

AOP 意为:面向切面编程,通过预编译的方式和运行期间动态代理实现程序功能功能的统一维护。其实 AOP 也是 OOP 的延续,在 Spring 框架中是一个非常重要的内容,使用 AOP 可以对业务逻辑的各个部分进行隔离,从而使各模块间的业务逻辑耦合度降低,提高代码的可复用性,同时也能提高开发效率。

qq_63815371的博客 1216

汽车UDS诊断详解及Vector相关工具链使用说明——总述

1.什么是诊断 车辆在运行过程中,不可避免地会发生一些故障,为了确保行车安全,我们要求车上的ECU能够实时监测部件的运行状态,一旦发现异常情况,能通过点亮报警灯等方式提示驾驶员。但是,点亮报警灯只能告诉驾驶员车辆发生了故障,最多只能定位到故障ECU,比如ABS报警灯亮说明ABS系统出现故障,但具体是什么部件发生故障并不能通过报警灯显示出来。这时就需要ECU在本地存储一个与故障相对应的故障代码,在进行维修的时候,可以通过车上的OBD接口连接诊断仪,把这个存储的故障代码读取出来,从而进一步定位到更加具体的故障部

weixin_42967006的博客 2万+

Java笔记:手写spring之aop

AOP(Aspect-oriented Programming), AOP翻译过来叫面向切面编程, 核心就是这个切面.切面表示从业务逻辑中分离出来的横切逻辑, 比如性能监控, 日志记录, 权限控制等, 这些功能都可以从核心业务逻辑代码中抽离出来.也就是说, 通过AOP可以解决代码耦合问题, 让职责更加单一。在程序运行期间,在不修改源码的情况下对方法进行功能增强。Spring通过动态代理技术动态的生成代理对象,代理对象方法执行时进行增强功能的介入,在去调用目标对象的方法,从而完成功能的增强。

热情、奔放、快乐编程! 488

10、皮肤 - 神经记录实验全流程解析

本博客详细介绍了皮肤-神经记录实验的全流程,涵盖实验所需的材料准备和具体操作方法。内容包括细胞外记录设备的设置、合成间质液(SIF)的制备与调节、小鼠后爪皮肤和胫神经的手术解剖步骤、清洁解剖后的记录准备、纤维分离与感受野识别方法,以及神经纤维机械响应的测量。该实验为研究神经纤维的活动与功能提供了重要的技术支持,适用于神经科学研究领域。

backprop5master的博客 185

TIA protal与SCL从入门到精通(4)——软件单元使用

平台: TIA portal 15.1 1.添加软件单元 添加软件单元如下图: 关于软件单元使用基本限制,看如下文章即可 TIA protal与SCL从入门到精通(3)——软件单元基本介绍 每个软件单元是一个独立结构,所以每个软件单元的运行方式与实际PLC类似,所以首先添加主函数块: 注意:无论系统是否是具有并发性(这里不要混淆并行与并发的概念),在PLC所有主函数执行总是按主函数依次完成...

苦走一口田 7375

第三篇:Spring源码篇-手写篇-手写AOP

手写IoC和DI后已经实现的类图结构。

yqqの博客 434

FPGA工程师面试试题集锦11~20

时钟抖动是指芯片的某一个给定点上时钟周期发生暂时性变化,也就是说时钟周期在不同的周期上可能加长或缩短。它是一个平均值为0的平均变量。

FPGA/MATLAB学习教程/源码/项目合作开发 678

Java 手写 Spring框架 IOC 和 AOP---SpringIoC高级应用面试知识点,源码

本文将首先通过手写Spring,了解Spring基本思想,然后介绍Spring的一些高级用法,随后深度剖析其源码,让读者有更深入的了解====本文源码基于5.1.12版本讲解

殷志鹏的博客 1629

深度学习工具包 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")

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

深入解析 Spring IOC & AOP:原理、源码与实战

IOC(Inversion of Control)是 Spring 的核心思想,它将对象的创建和依赖关系的管理交给 Spring 容器,避免了传统的。今天,我们将深入剖析它们的原理,结合源码解析,并通过 Java 代码实战来掌握这两个核心概念。我们用 Java 代码手写一个简化版的 IOC 容器,模拟 Spring 依赖注入的实现。实现 AOP,模拟 Spring。在 Spring 中,我们可以使用。Spring AOP 主要通过。Spring AOP 主要使用。注解实现 AOP 事务管理。

工一木子 974

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Java 手写 Spring框架 IOC 和 AOP以及 高级应用 和 实际源码剖析,从思想到实现一步步演变,充分体会Spring的思想魅力,第三章:SpringAOP高级应用面试知识点,源码

本文将首先通过手写Spring,了解Spring基本思想,然后介绍Spring的一些高级用法,随后深度剖析其源码,让读者有更深入的了解====本文源码基于5.1.12版本讲解

殷志鹏的博客 430

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

spring aop原理_爽!阿里大牛Spring IOC+AOP深度分析笔记,太牛了

前言Spring框架自诞生来就备受开发者青睐,很多开发者一致认为它是目前最屌的Java项目,正是因为它的“过人之处”,市面上99%的企业都在使用Spring框架。所以,Spring一直Java技术里的重点难点,也是Java开发者面试中的重点,重要性不言而喻。谷歌大牛甚至直言:“对于Java开发者,学习Java就是在学Spring。”本篇内容一定是你从所未见过的学习笔记,我将分成4个部分跟大家分享,...

weixin_39665507的博客 114

一文带你实现手写spring框架(一)

手把手带你实现spring框架

weixin_45642975的博客 964

《手写Spring渐进式源码实践》实践笔记(开篇)

Spring框架是一个轻量级的开源Java框架,旨在提高开发效率和系统可维护性。其核心是IOC(控制反转)和AOP(面向切面编程),提供了丰富的功能模块,如数据访问、Web支持、集成等。Spring使Java企业级开发更加简单,并为POJO对象提供企业级服务。Spring经历了多个版本的迭代,直接上手看源码,会让人一脸懵。通过做一个简易版的Spring框架,对代码剥丝抽茧,体现核心功能,把最直接相干的设计思路呈现出来,我们再进行学习,才更容易理解。

weixin_37693760的博客 1066

我终于找到了!阿里大牛Spring IOC+AOP深度分析笔记,由浅入深,面面俱到

Spring框架自诞生来就备受开发者青睐,很多开发者一致认为它是目前最屌的Java项目,正是因为它的“过人之处”,市面上99%的企业都在使用Spring框架。 所以,Spring一直Java技术里的重点难点,也是Java开发者面试中的重点,重要性不言而喻。 谷歌大牛甚至直言:“对于Java开发者,学习Java就是在学Spring。”

m0_57042151的博客 123

阿里大佬《Spring IOC+AOP深度分析》笔记,看完犹如醍醐灌顶

Spring框架对于Java开发者的重要性真的是不言而喻,工作面试学习都是重点知识。这两位大牛总结的笔记相信对你学习Spring必然有较大的帮助。

m0_57042151的博客 125

Spring框架:谈谈对IOC和AOP的理解

在java面试中,如果我们被问及Spring框架的相关问题,那么一定避不开对Spring中的IOC和AOP的理解和使用,本文就简单谈论对于Spring中IOC和AOP的理解。 一、IOC的理解 1.1 IOC的概念与原理 IOC,即控制反转,把对象的创建、初始化、销毁交给 Spring 来管理,而不是由开发者控制,实现控制反转。IOC 思想基于 IOC 容器完成,IOC 容器底层就是对象工厂(BeanFactory 接口)。IOC的原理是基于xml解析、工厂设计...

weixin_48016395的博客 2万+

Spring IOC 和 AOP

Spring框架中的IoC(Inverse of Control,控制反转)和AOP(Aspect-Oriented Programming,面向切面编程)是其两大核心特性,它们共同为Java应用程序带来了更高的灵活性、可维护性和松耦合度。

Good good study,day day up 2856

Spring中的IOC和AOP

Spring 框架是一款轻量级的开发框架,核心思想是 IOC(控制反转)和 AOP(面向切面编程)。为 Java 应用程序开发提供组件管理服,用于组件之间的解耦,以及简化第三方JavaEE中间件技术的使用(IMS、任务调度、缓存、ORM 框架),是一个基础架构型的开发框架;。AOP(Aspect-Oriented Programming,面向切面编程)是一种编程范式,它允许开发者将横切关注点(如日志记录、事务管理、安全性等)从业务逻辑中分离出来。

zenbior的博客 3313

Spring 框架IOC和AOP

Spring 是一个分层的 JavaSE/EE 全栈轻量级开源框架,核心解决业务逻辑层与其他层的耦合问题,将面向接口的编程思想贯穿整个系统。它不是要替代现有技术,而是通过整合各类优秀框架(如 MyBatis、Struts2 等),为开发者提供一套统一的开发规范。简单来说,Spring 就像一个 "超级工厂",帮你管理所有对象的创建和依赖关系;IOC(控制反转)和AOP(面向切面编程)。IOC(Inverse of Control,控制反转)是 Spring 的核心设计思想 ——

asad6的博客 847

Spring实现IOC和AOP的底层原理

Spring框架是Java企业级应用开发中的核心框架之一,其核心思想可以概括为IOC(Inversion of Control,控制反转)和AOP(Aspect Oriented Programming,面向切面编程)。IOC通过依赖注入实现对象之间的解耦,而AOP则提供了一种在不修改源代码的情况下,为程序动态添加额外功能的技术手段。本文将深入探讨Spring实现IOC和AOP的底层原理。Spring的IOC和AOP是实现松耦合、高内聚和代码复用的重要手段。

qq_30009397的博客 2102
上一篇: java BIO、NIO、AIO详细笔记
下一篇: Java 手写 Spring框架 IOC 和 AOP---SpringIoC高级应用面试知识点,源码
ydenergy_殷志鹏
博客等级 码龄7年 5882粉丝 543原创
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ydenergy_殷志鹏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值