1、问题

问题：想要添加日志记录、性能监控、安全监测

2、最初解决方案

2.1、最初解决方案

缺点：太多重复代码，且紧耦合

2.2、抽象类进行共性设计，子类进行个性设计，此处不讲解，缺点一荣俱荣，一损俱损

2.3、使用装饰器模式/代理模式改进的解决方案

装饰器模式：动态地给一个对象添加一些额外的职责。就增加功能来说， 装饰器模式相比生成子类更为灵活。
代理模式：为其他对象提供一种代理以控制对这个对象的访问。




 
缺点：紧耦合，每个业务逻辑需要一个装饰器实现或代理

2.4、JDK动态代理解决方案（比较通用的解决方案） 
  1. public class MyInvocationHandler implements InvocationHandler {
  2. private Object target;
  3. public MyInvocationHandler(Object target) {
  4. this.target = target;
  5. }
  6. @Override
  7. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  8. //1.记录日志    2.时间统计开始      3.安全检查
  9. Object retVal = method.invoke(target, args);
  10. //4.时间统计结束
  11. return retVal;
  12. }
  13. public static Object proxy(Object target) {
  14. return Proxy.newProxyInstance(target.getClass().getClassLoader(),
  15. target.getClass().getInterfaces(), new MyInvocationHandler(target));
  16. }
  17. }

编程模型

  1. //proxy     在其上调用方法的代理实例
  2. //method 拦截的方法
  3. //args       拦截的参数
  4. Override
  5. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  6. Object retVal=null;
  7. //预处理
  8. //前置条件判断
  9. boolean ok = true;
  10. if(!ok) {//不满足条件
  11. throw new RuntimeException("你没有权限");
  12. }
  13. else {//反射调用目标对象的某个方法
  14. retVal = method.invoke(target, args);
  15. }
  16. //后处理
  17. return retVal;
  18. }

缺点：使用麻烦，不能代理类，只能代理接口

CGLIB动态代理解决方案（比较通用的解决方案）
  1. public class MyInterceptor implements MethodInterceptor  {
  2. private Object target;
  3. public MyInterceptor(Object target) {
  4. this.target = target;
  5. }
  6. @Override
  7. public Object intercept(Object proxy, Method method, Object[] args,
  8. MethodProxy invocation) throws Throwable {
  9. //1.记录日志 2.时间统计开始   3.安全检查
  10. Object retVal = invocation.invoke(target, args);
  11. //4.时间统计结束
  12. return retVal;
  13. }
  14. public static Object proxy(Object target) {
  15. return Enhancer.create(target.getClass(), new MyInterceptor(target));
  16. }
  17. }

编程模型

  1. //proxy 在其上调用方法的代理实例    method拦截的方法    args  拦截的参数
  2. //invocation 用来去调用被代理对象方法的
  3. @Override
  4. public Object intercept(Object proxy, Method method, Object[] args,
  5. MethodProxy invocation) throws Throwable {
  6. //预处理
  7. //前置条件判断
  8. boolean ok = true;
  9. if(!ok) {//不满足条件
  10. throw new RuntimeException("出错了");
  11. }
  12. else {//调用目标对象的某个方法
  13. Object retVal = invocation.invoke(target, args);
  14. }
  15. //后处理
  16. return retVal;
  17. }
优点：能代理接口和类
缺点：使用麻烦，不能代理final类

动态代理本质

本质：对目标对象增强
           最终表现为类（动态创建子类），看手工生成（子类）还是自动生成（子类）
代理限制：
           只能在父类方法被调用之前或之后进行增强（功能的修改），不能在中间进行修改，要想在方法调用中增强，需要ASM(java 字节码生成库)
其他动态代理框架
jboss：javassist （hibernate 3.3中默认为javassist）
                           （hibernate 3.3之前中默认为cglib）


 




 
2.5、AOP解决方案（通用且简单的解决方案）
  1. @Aspect
  2. public class PayEbiAspect {
  3. @Pointcut(value="execution(* pay(..))")
  4. public void pointcut() {}
  5. @Around(value="pointcut()")
  6. public Object around(ProceedingJoinPoint pjp) throws Throwable {
  7. //1.记录日志
  8. //2.时间统计开始
  9. //3.安全检查
  10. Object retVal = pjp.proceed();//调用目标对象的真正方法
  11. //4.时间统计结束
  12. return retVal;
  13. }
  14. }
编程模型
  1. //2 切入点
  2. @Pointcut(value="execution(* *(..))")
  3. public void pointcut() {}
  4. //3 拦截器的interceptor
  5. @Around(value="pointcut()")
  6. public Object around(ProceedingJoinPoint pjp) throws Throwable {
  7. Object retVal=null;
  8. //预处理
  9. //前置条件判断
  10. boolean ok = true;
  11. if(!ok) {//不满足条件
  12. throw new RuntimeException("你没有权限");
  13. }
  14. else {//调用目标对象的某个方法
  15. retVal = pjp.proceed();
  16. }
  17. //后处理
  18. return retVal;
  19. }
缺点：依赖AOP框架 

AOP入门
概念：
n关注点：可以认为是所关注的任何东西，比如上边的支付组件；
n关注点分离：将问题细化为单独部分，即可以理解为不可再分割的组件，如上边的日志组件和支付组件；
n横切关注点：会在多个模块中出现，使用现有的编程方法，横切关注点会横越多个模块，结果是使系统难以设计、理解、实现和演进，如日志组件横切于支付组件。
织入：横切关注点分离后，需要通过某种技术将横切关注点融合到系统中从而完成需要的功能，因此需要织入，织入可能在编译期、加载期、运行期等进行。

nAOP是什么(Aspect   Oriented   Programming)
 AOP是一种编程范式，提供从另一个角度来考虑程序结构以完善面向对象编程（OOP）。
 AOP为开发者提供了一种描述横切关注点的机制，并能够自动将横切关注点织入到面向对象的软件系统中，从而实现了横切关注点的模块化。
 AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任，例如事务处理、日志管理、权限控制等，封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。
nAOP能干什么，也是AOP带来的好处
1：降低模块的耦合度
2：使系统容易扩展
3：设计决定的迟绑定：使用AOP,设计师可以推迟为将来的需求作决定，因为它
可以把这种需求作为独立的方面很容易的实现。
4：更好的代码复用性


 
AOP基本概念
 连接点（Joinpoint）：
    表示需要在程序中插入横切关注点的扩展点，连接点可能是类初始化、方法执行、方法调用、字段调用或处理异常等等，Spring只支持方法执行连接点，在AOP中表示为“在哪里做”；
切入点（Pointcut）：
    选择一组相关连接点的模式，即可以认为连接点的集合，Spring支持perl5正则表达式和AspectJ切入点模式，Spring默认使用AspectJ语法，在AOP中表示为“在哪里做的集合”；
增强（Advice）：或称为增强
    在连接点上执行的行为，增强提供了在AOP中需要在切入点所选择的连接点处进行扩展现有行为的手段；包括前置增强（before advice）、后置增强 (after advice)、环绕增强 （around advice），在Spring中通过代理模式实现AOP，并通过拦截器模式以环绕连接点的拦截器链织入增强 ；在AOP中表示为“做什么”；
方面/切面（Aspect）：
      横切关注点的模块化，比如上边提到的日志组件。可以认为是增强、引入和切入点的组合；在Spring中可以使用Schema和@AspectJ方式进行组织实现；在AOP中表示为“在哪里做和做什么集合”；
目标对象（Target Object）：
    需要被织入横切关注点的对象，即该对象是切入点选择的对象，需要被增强的对象，从而也可称为“被增强对象”；由于Spring AOP 通过代理模式实现，从而这个对象永远是被代理对象，在AOP中表示为“对谁做”；
AOP代理（AOP Proxy）：
    AOP框架使用代理模式创建的对象，从而实现在连接点处插入增强（即应用切面），就是通过代理来对目标对象应用切面。在Spring中，AOP代理可以用JDK动态代理或CGLIB代理实现，而通过拦截器模型应用切面。
织入（Weaving）：
    织入是一个过程，是将切面应用到目标对象从而创建出AOP代理对象的过程，织入可以在编译期、类装载期、运行期进行。
引入（inter-type declaration）：
    也称为内部类型声明，为已有的类添加额外新的字段或方法，Spring允许引入新的接口（必须对应一个实现）到所有被代理对象（目标对象）, 在AOP中表示为“做什么（新增什么）”；

AOP的Advice类型
前置增强（Before advice）：
    在某连接点之前执行的增强，但这个增强不能阻止连接点前的执行（除非它抛出一个异常）。
后置返回增强（After returning advice）：
    在某连接点正常完成后执行的增强：例如，一个方法没有抛出任何异常，正常返回。
后置异常增强（After throwing advice）：
    在方法抛出异常退出时执行的增强。
后置最终增强（After (finally) advice）：
    当某连接点退出的时候执行的增强（不论是正常返回还是异常退出）。
环绕增强（Around Advice）：
    包围一个连接点的增强，如方法调用。这是最强大的一种增强类型。 环绕增强可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。


AOP开发步骤
  类似于IoC/DI容器开发步骤，需要描述哪个连接点需要哪个通用功能（增强）

横切关注点的表现有：　　

　　·代码纠结/混乱——当一个模块或代码段同时管理多个关注点时发生这种情况。　

　　·代码分散——当一个关注点分布在许多模块中并且未能很好地局部化和模块化时发生这种情况 。
AOP包括三个清晰的开发步骤：
1：功能横切：找出横切关注点。
2：实现分离：各自独立的实现这些横切关注点所需要完成的功能。
3：功能回贴：在这一步里，方面集成器通过创建一个模块单元—— 方面来指定重组的规则。重组过程——也叫织入或结合—— 则使用这些信息来构建最终系统。

推荐阅读书籍：
AspectJ in Action

AOSD中文版--基于用例的面向方面软件开发


1、问题

问题：想要添加日志记录、性能监控、安全监测

2、最初解决方案

2.1、最初解决方案

缺点：太多重复代码，且紧耦合

2.2、抽象类进行共性设计，子类进行个性设计，此处不讲解，缺点一荣俱荣，一损俱损

2.3、使用装饰器模式/代理模式改进的解决方案

装饰器模式：动态地给一个对象添加一些额外的职责。就增加功能来说， 装饰器模式相比生成子类更为灵活。
代理模式：为其他对象提供一种代理以控制对这个对象的访问。




 
缺点：紧耦合，每个业务逻辑需要一个装饰器实现或代理

2.4、JDK动态代理解决方案（比较通用的解决方案） 
  1. public class MyInvocationHandler implements InvocationHandler {
  2. private Object target;
  3. public MyInvocationHandler(Object target) {
  4. this.target = target;
  5. }
  6. @Override
  7. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  8. //1.记录日志    2.时间统计开始      3.安全检查
  9. Object retVal = method.invoke(target, args);
  10. //4.时间统计结束
  11. return retVal;
  12. }
  13. public static Object proxy(Object target) {
  14. return Proxy.newProxyInstance(target.getClass().getClassLoader(),
  15. target.getClass().getInterfaces(), new MyInvocationHandler(target));
  16. }
  17. }

编程模型

  1. //proxy     在其上调用方法的代理实例
  2. //method 拦截的方法
  3. //args       拦截的参数
  4. Override
  5. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  6. Object retVal=null;
  7. //预处理
  8. //前置条件判断
  9. boolean ok = true;
  10. if(!ok) {//不满足条件
  11. throw new RuntimeException("你没有权限");
  12. }
  13. else {//反射调用目标对象的某个方法
  14. retVal = method.invoke(target, args);
  15. }
  16. //后处理
  17. return retVal;
  18. }

缺点：使用麻烦，不能代理类，只能代理接口

CGLIB动态代理解决方案（比较通用的解决方案）
  1. public class MyInterceptor implements MethodInterceptor  {
  2. private Object target;
  3. public MyInterceptor(Object target) {
  4. this.target = target;
  5. }
  6. @Override
  7. public Object intercept(Object proxy, Method method, Object[] args,
  8. MethodProxy invocation) throws Throwable {
  9. //1.记录日志 2.时间统计开始   3.安全检查
  10. Object retVal = invocation.invoke(target, args);
  11. //4.时间统计结束
  12. return retVal;
  13. }
  14. public static Object proxy(Object target) {
  15. return Enhancer.create(target.getClass(), new MyInterceptor(target));
  16. }
  17. }

编程模型

  1. //proxy 在其上调用方法的代理实例    method拦截的方法    args  拦截的参数
  2. //invocation 用来去调用被代理对象方法的
  3. @Override
  4. public Object intercept(Object proxy, Method method, Object[] args,
  5. MethodProxy invocation) throws Throwable {
  6. //预处理
  7. //前置条件判断
  8. boolean ok = true;
  9. if(!ok) {//不满足条件
  10. throw new RuntimeException("出错了");
  11. }
  12. else {//调用目标对象的某个方法
  13. Object retVal = invocation.invoke(target, args);
  14. }
  15. //后处理
  16. return retVal;
  17. }
优点：能代理接口和类
缺点：使用麻烦，不能代理final类

动态代理本质

本质：对目标对象增强
           最终表现为类（动态创建子类），看手工生成（子类）还是自动生成（子类）
代理限制：
           只能在父类方法被调用之前或之后进行增强（功能的修改），不能在中间进行修改，要想在方法调用中增强，需要ASM(java 字节码生成库)
其他动态代理框架
jboss：javassist （hibernate 3.3中默认为javassist）
                           （hibernate 3.3之前中默认为cglib）


 




 
2.5、AOP解决方案（通用且简单的解决方案）
  1. @Aspect
  2. public class PayEbiAspect {
  3. @Pointcut(value="execution(* pay(..))")
  4. public void pointcut() {}
  5. @Around(value="pointcut()")
  6. public Object around(ProceedingJoinPoint pjp) throws Throwable {
  7. //1.记录日志
  8. //2.时间统计开始
  9. //3.安全检查
  10. Object retVal = pjp.proceed();//调用目标对象的真正方法
  11. //4.时间统计结束
  12. return retVal;
  13. }
  14. }
编程模型
  1. //2 切入点
  2. @Pointcut(value="execution(* *(..))")
  3. public void pointcut() {}
  4. //3 拦截器的interceptor
  5. @Around(value="pointcut()")
  6. public Object around(ProceedingJoinPoint pjp) throws Throwable {
  7. Object retVal=null;
  8. //预处理
  9. //前置条件判断
  10. boolean ok = true;
  11. if(!ok) {//不满足条件
  12. throw new RuntimeException("你没有权限");
  13. }
  14. else {//调用目标对象的某个方法
  15. retVal = pjp.proceed();
  16. }
  17. //后处理
  18. return retVal;
  19. }
缺点：依赖AOP框架 

AOP入门
概念：
n关注点：可以认为是所关注的任何东西，比如上边的支付组件；
n关注点分离：将问题细化为单独部分，即可以理解为不可再分割的组件，如上边的日志组件和支付组件；
n横切关注点：会在多个模块中出现，使用现有的编程方法，横切关注点会横越多个模块，结果是使系统难以设计、理解、实现和演进，如日志组件横切于支付组件。
织入：横切关注点分离后，需要通过某种技术将横切关注点融合到系统中从而完成需要的功能，因此需要织入，织入可能在编译期、加载期、运行期等进行。

nAOP是什么(Aspect   Oriented   Programming)
 AOP是一种编程范式，提供从另一个角度来考虑程序结构以完善面向对象编程（OOP）。
 AOP为开发者提供了一种描述横切关注点的机制，并能够自动将横切关注点织入到面向对象的软件系统中，从而实现了横切关注点的模块化。
 AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任，例如事务处理、日志管理、权限控制等，封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。
nAOP能干什么，也是AOP带来的好处
1：降低模块的耦合度
2：使系统容易扩展
3：设计决定的迟绑定：使用AOP,设计师可以推迟为将来的需求作决定，因为它
可以把这种需求作为独立的方面很容易的实现。
4：更好的代码复用性


 
AOP基本概念
 连接点（Joinpoint）：
    表示需要在程序中插入横切关注点的扩展点，连接点可能是类初始化、方法执行、方法调用、字段调用或处理异常等等，Spring只支持方法执行连接点，在AOP中表示为“在哪里做”；
切入点（Pointcut）：
    选择一组相关连接点的模式，即可以认为连接点的集合，Spring支持perl5正则表达式和AspectJ切入点模式，Spring默认使用AspectJ语法，在AOP中表示为“在哪里做的集合”；
增强（Advice）：或称为增强
    在连接点上执行的行为，增强提供了在AOP中需要在切入点所选择的连接点处进行扩展现有行为的手段；包括前置增强（before advice）、后置增强 (after advice)、环绕增强 （around advice），在Spring中通过代理模式实现AOP，并通过拦截器模式以环绕连接点的拦截器链织入增强 ；在AOP中表示为“做什么”；
方面/切面（Aspect）：
      横切关注点的模块化，比如上边提到的日志组件。可以认为是增强、引入和切入点的组合；在Spring中可以使用Schema和@AspectJ方式进行组织实现；在AOP中表示为“在哪里做和做什么集合”；
目标对象（Target Object）：
    需要被织入横切关注点的对象，即该对象是切入点选择的对象，需要被增强的对象，从而也可称为“被增强对象”；由于Spring AOP 通过代理模式实现，从而这个对象永远是被代理对象，在AOP中表示为“对谁做”；
AOP代理（AOP Proxy）：
    AOP框架使用代理模式创建的对象，从而实现在连接点处插入增强（即应用切面），就是通过代理来对目标对象应用切面。在Spring中，AOP代理可以用JDK动态代理或CGLIB代理实现，而通过拦截器模型应用切面。
织入（Weaving）：
    织入是一个过程，是将切面应用到目标对象从而创建出AOP代理对象的过程，织入可以在编译期、类装载期、运行期进行。
引入（inter-type declaration）：
    也称为内部类型声明，为已有的类添加额外新的字段或方法，Spring允许引入新的接口（必须对应一个实现）到所有被代理对象（目标对象）, 在AOP中表示为“做什么（新增什么）”；

AOP的Advice类型
前置增强（Before advice）：
    在某连接点之前执行的增强，但这个增强不能阻止连接点前的执行（除非它抛出一个异常）。
后置返回增强（After returning advice）：
    在某连接点正常完成后执行的增强：例如，一个方法没有抛出任何异常，正常返回。
后置异常增强（After throwing advice）：
    在方法抛出异常退出时执行的增强。
后置最终增强（After (finally) advice）：
    当某连接点退出的时候执行的增强（不论是正常返回还是异常退出）。
环绕增强（Around Advice）：
    包围一个连接点的增强，如方法调用。这是最强大的一种增强类型。 环绕增强可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。


AOP开发步骤
  类似于IoC/DI容器开发步骤，需要描述哪个连接点需要哪个通用功能（增强）

横切关注点的表现有：　　

　　·代码纠结/混乱——当一个模块或代码段同时管理多个关注点时发生这种情况。　

　　·代码分散——当一个关注点分布在许多模块中并且未能很好地局部化和模块化时发生这种情况 。
AOP包括三个清晰的开发步骤：
1：功能横切：找出横切关注点。
2：实现分离：各自独立的实现这些横切关注点所需要完成的功能。
3：功能回贴：在这一步里，方面集成器通过创建一个模块单元—— 方面来指定重组的规则。重组过程——也叫织入或结合—— 则使用这些信息来构建最终系统。

推荐阅读书籍：
AspectJ in Action

AOSD中文版--基于用例的面向方面软件开发


我对AOP的理解的更多相关文章

  1. 对IOC和DI以及AOP的理解

    为了理解Spring的IoC与DI从网上查了很多资料,作为初学者,下面的描述应该是最详细,最易理解的方式了. 首先想说说IoC(Inversion of Control,控制倒转).这是spring的 ...

  2. AOP 怎么理解？

    什么是 AOP ? AOP 为 Aspect Oriented Programming 的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP 是 OOP ...

  3. Spring AOP深入理解之拦截器调用

    Spring AOP深入理解之拦截器调用 Spring AOP代理对象生成回想 上一篇博客中:深入理解Spring AOP之二代理对象生成介绍了Spring代理对象是怎样生成的,当中重点介绍了JDK动 ...

  4. Spring框架学习（9）AOP技术理解与使用

    内容源自:AOP技术理解与使用 一.什么是AOP? aop技术是面向切面编程思想,作为OOP(面向对象编程)的延续思想添加到企业开发中,用于弥补OOP开发过程中的缺陷而提出的编程思想. AOP底层也是 ...

  5. Spring 的 IOC 和 AOP 的理解

    Spring 的 IOC 和 AOP 的理解: https://www.jianshu.com/p/bf1adc3b75e6 对Spring的核心(AOP和IOC)的理解(大白话) https://w ...

  6. 谈谈对AOP的理解

    Aspect Oriented Programming  面向切面编程.解耦是程序员编码开发过程中一直追求的.AOP也是为了解耦所诞生. 具体思想是:定义一个切面,在切面的纵向定义处理方法,处理完成之 ...

  7. 关于Spring中AOP的理解

    AOP简介[理解][重点] 1.AOP(Aspect Oriented Programing)面向切面/方面编程 2.AOP隶属软件工程的范畴,指导开发人员如何制作开发软件,进行结构设计 3.AOP联 ...

  8. 对Spring IOC和AOP的理解

    控制反转(IOC)是什么?(理解好Ioc的关键是要明确"谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了") 1.Ioc-Inversion of Contr ...

  9. Spring AOP概念理解

    1.我所知道的aop 初看aop,上来就是一大堆术语,而且还有个拉风的名字,面向切面编程,都说是OOP的一种有益补充等等.一下子让你不知所措,心想着:怪不得很多人都和我说aop多难多难.当我看进去以后 ...

随机推荐

  1. Android 四种常见的线程池

    引入线程池的好处 1)提升性能.创建和消耗对象费时费CPU资源 2)防止内存过度消耗.控制活动线程的数量,防止并发线程过多. 我们来看一下线程池的简单的构造 public ThreadPoolExec ...

  2. SSH深度历险（五） 深入浅出-----IOC AND AOP

    IOC就是Inversion of Control,控制反转.在Java开发中,IoC意味着将你设计好的类交给系统(容器)来控制实现,而不是在你的类内部控制.这称为控制反转. 本人理解:就是把原本你自 ...

  3. 每个程序员都应该用MBP

    换笔记本的想法很久了,前段时间换工作就想看换工作之后是什么情况吧.可能工作配的笔记本就是MBP.后来发现是想多了,新工作的笔记本是Thinkpad X240, 配置完全够用了,8G内存+128G的FL ...

  4. linux后台运行程序（secureCRT断掉或关闭后继续运行程序）

    secureCRT断掉后想继续运行程序.也就是程序会在后台一直执行到结束. secureCRT通过ssh联接到client端运行程序,如果关掉窗口或者断开连接时,任务会被kill. 为了程序能够后台执 ...

  5. 【Unity Shaders】Lighting Models —— 衣服着色器

    本系列主要参考<Unity Shaders and Effects Cookbook>一书(感谢原书作者),同时会加上一点个人理解或拓展. 这里是本书所有的插图.这里是本书所需的代码和资源 ...

  6. Linux之命令的组合

    在Linux下有好多经典的操作,其中尤为经典的是命令的组合,不管是作为参数,还是命令之间的配合,都做得比较完善.下面看一下常用的一些命令吧. 1.连续运行多个命令就可以使用':'作为分隔,但是缺点就是 ...

  7. Dynamics CRM2013 任务列表添加自定义按钮

    任务列表的command bar 上面添加自定义按钮如下 要注意的是此处的列表不是任务实体而是活动实体,如果你是在任务实体的home栏上面加那你永远看不见按钮的显示,但如果是要在任务的表单界面上加按钮 ...

  8. Linux IPC实践(3) --具名FIFO

    FIFO具名/命名管道 (匿名)管道应用的一个限制就是只能在具有共同祖先(具有亲缘关系)的进程间通信. 如果我们想在不相关的进程之间交换数据,可以使用FIFO文件来做这项工作,它经常被称为命名管道;命 ...

  9. 总账：日记账导入流程(文档 ID 1591640.1)

    文档内容   概要   历史记录   详细信息   GL_INTERFACE_CONTROL   GL_INTERFACE_HISTORY   GL_IMPORT_REFERENCES   摘要   ...

  10. 《java入门第一季》之LinkList模拟桟结构案例

    需求:请用LinkedList模拟栈数据结构的集合,并测试 题目的意思是: 你自己的定义一个集合类,在这个集合类内部可以使用LinkedList模拟. 定义一个类叫MyStack代码如下: packa ...