当前位置:首页 > Java > Javapdf电子书下载
《JAVA核心技术卷2:高级特征(第8版)》电子书封面

JAVA核心技术卷2:高级特征(第8版)

  • 发布时间:2021年03月27日 10:53:51
  • 作者:斯特曼
  • 大小:57.40MB
  • 类别:Java电子书
  • 格式:PDF
  • 版本:超清版
  • 评分:7.9

    JAVA核心技术卷2:高级特征(第8版) PDF 超清版

      给大家带来的一篇关于Java相关的电子书资源,介绍了关于JAVA、核心技术方面的内容,本书是由机械工业出版社出版,格式为PDF,资源大小57.40MB,斯特曼编写,目前豆瓣、亚马逊、当当、京东等电子书综合评分为:8.5分

      Tags:java 核心技术 

      内容介绍

      中文名: JAVA核心技术卷2:高级特征(原书第8版)

      作者: 

      发行时间: 2008年12月01日

      《JAVA核心技术卷2:高级特征》是Java技术权威指南,全面覆盖Java技术的高级主题,包括流与文件、XML、网络、数据库编程、高级Swing、高级 AWT、JavaBean构件、安全、分布式对象、脚本、编译与注解处理等,同时涉及本地化、国际化以及Java SE 6的内容。《JAVA核心技术卷Ⅱ:高级特征》对Java技术的阐述精确到位,叙述方式深入浅出,并包含大量示例,从而帮助读者充分理解Java语言以及Java类库的相关特性。

      《JAVA核心技术卷2:高级特征》适合软件开发人员、高等院校教师和学生参考。

      -可在(网盘分流地址):本页“用户评论”处-找-。

      目录

      • 第一章 流与文件
      • 1.1 流
      • 1.1.1 读入和写出字节
      • 1.1.2 完整的流家族
      • 1.1.3 组合流过滤器
      • 1.2 文本输入与输出
      • 1.2.1 如何写出文本输出
      • 1.2.2 如何读入文本输入
      • 1.2.3 以文本格式存储对象
      • 1.2.4 字符集
      • 1.3 读入和写出二进制数据
      • 1.3.1 随机访问文件
      • 1.4 ZIP文档
      • 1.5 对象流与序列化
      • 1.5.1 理解对象序列化的文件格式
      • 1.5.2 修改缺省的序列化机制
      • 1.5.3 序列化单例和类型安全的枚举
      • 1.5.4 版本管理
      • 1.5.5 为克隆使用序列化
      • 1.6 文件管理
      • 1.7 新I/O
      • 1.7.1 内存映射文件
      • 1.7.2 缓冲区数据结构
      • 1.7.3 文件加锁机制

      读书笔记

      Java核心库实现AOP过程

      这篇文章是关于Java的一个疑难杂症,通过利用Java核心库实现简单的AOP方法,并把实例代码做了分析对照,以下是全部内容:

      Spring是一个十分火热开源框架,而AOP(面向切面编程)则是Spring最重要的概念之一,为了更好的理解和学习AOP的思想,使用核心库来实现一次不失为一个好方法。

      首先介绍一下AOP的概念,AOP(Aspect Oriented Programming),即面向切面编程,所谓的面向切面编程,就是从一个横切面的角度去设计代码的思想,传统的OOP思想是用封装继承和多态构造一种纵向的层次关系,但不适合定义横向的关系,而AOP思想则对此进行了很好的补充。

      例如日志管理代码往往横向的散布在很多对象层次中,但跟它对应的对象的核心功能可以说是毫无关系,还有很多类似的代码,如权限验证,调试输出,事务处理等,也都是如此,这样的话就不利于代码的复用和管理了。

      这时候AOP技术就应运而生了,它利用“横切”技术,深入封装对象的内部,并将那些影响了多个类的公共行为封装到一个可重用模块,并将其命名为"Aspect",即切面。所谓"切面",简单说就是那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,便于减少系统的重复代码,降低模块之间的耦合度,并有利于后续的可操作性和可维护性。

      那么AOP又是如何实现的呢?

      答案是动态代理(关于代理会有另外篇章做详细介绍,这里就不赘述了)。实现动态代理有两种方式,一种是JDK动态代理,一种是CGLib动态代理。

      那么分别使用两种方式来做一个简单的栗子。

      先设计一个场景,假设我们有一个计算接口ICalculator和实现了该接口的计算器类CalculatorImpl。

      public interface ICalculator {
       //加法运算
       public int add(int a,int b);
       //减法
       public int subtract(int a,int b);
       //乘法
       public int multiply(int a,int b);
       //除法
       public int devide(int a,int b);
      }
      public class CalculatorImpl implements ICalculator{
       @Override
       public int add(int a, int b) {
        return a + b;
       }
       @Override
       public int subtract(int a, int b) {
        return a - b;
       }
       @Override
       public int multiply(int a, int b) {
        return a * b;
       }
       @Override
       public int devide(int a, int b) {
        return a / b;
       }
      }

      如何在不改动原来计算器类内部代码的情况下记录计算器各个方法使用的总次数呢?

      有了动态代理后,其实就很简单了,先创建一个类并实现InvocationHandler接口,覆盖invoke方法,

      public class TestHandler implements InvocationHandler {
       private Object targetObject;
       private int useTimes;
       //绑定委托对象,并返回代理类
       public Object bind(Object targetObject){
        this.targetObject = targetObject;
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),targetObject.getClass().getInterfaces(),this);
       }
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //do something
        before();
        Object result = method.invoke(targetObject,args);
        after();
        return result;
       }
       private void before(){
        System.out.println("we can do something before calculate.");
       }
       private void after(){
        useTimes++;
        System.out.println("已使用:"+useTimes+"次");
       }
      }

      别看代码好像有点多,其实主要的方法就是invoke方法,里面的Object result = method.invoke(targetObject,args);相当于继续用原来的参数执行原来方法。这里的before和after为自定义的函数,可以在目标代码执行前后做一些我们想要做的事情,比如这里的使用次数统计。

      在bind方法里,传入目标代理对象,并返回一个代理类实例。接下来我们看看如何使用:

      public class TestProxy {
       public static void main(String[] args) {
        TestHandler proxy = new TestHandler();
        ICalculator calculator = (ICalculator)proxy.bind(new CalculatorImpl());
        int result = calculator.add(1,2);
        System.out.println("result is:"+result);
        result = calculator.subtract(3,2);
        System.out.println("result is:"+result);
        result = calculator.multiply(4,6);
        System.out.println("result is:"+result);
        result = calculator.devide(6,2);
        System.out.println("result is:"+result);
       }
      }

      我们先定义一个TestHandler,然后通过bind方法来获得一个代理实例,之后我们就可以直接使用这个实例了。运行结果如下:

      we can do something before calculate.
      已使用:1次
      result is:3
      we can do something before calculate.
      已使用:2次
      result is:1
      we can do something before calculate.
      已使用:3次
      result is:24
      we can do something before calculate.
      已使用:4次
      result is:3

      这样我们就实现了不修改CalculatorImpl内部代码的情况下对代码进行扩展。

      接下来用CGLib的方式来实现一次。

      先创建一个类来实现MethodInterceptor接口,并覆盖intercept方法。其他代码跟使用JDK代理大同小异,仅仅是获取代理对象的过程有所差异。

      public class CGLibProxy implements MethodInterceptor {
       private int useTimes;
       private Object target;
      
       public Object getInstance(Object target){
        this.target=target;
        Enhancer enhancer =new Enhancer();
        enhancer.setSuperclass(this.target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
       }
       @Override
       public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object result = methodProxy.invokeSuper(o,objects);
        after();
        return result;
       }
       private void before(){
        System.out.println("we can do something before calculate.");
       }
       private void after(){
        useTimes++;
        System.out.println("已使用:"+useTimes+"次");
       }
      }

      测试一下:

      public class TestCGLibProxy {
       public static void main(String[] args) {
        CGLibProxy cgLibProxy = new CGLibProxy();
        ICalculator calculator = (ICalculator) cgLibProxy.getInstance(new CalculatorImpl());
        int result = calculator.add(1,2);
        System.out.println("result is:"+result);
        result = calculator.subtract(3,2);
        System.out.println("result is:"+result);
        result = calculator.multiply(4,6);
        System.out.println("result is:"+result);
        result = calculator.devide(6,2);
        System.out.println("result is:"+result);
       }
      }

      运行结果如下:

      we can do something before calculate.
      已使用:1次
      result is:3
      we can do something before calculate.
      已使用:2次
      result is:1
      we can do something before calculate.
      已使用:3次
      result is:24
      we can do something before calculate.
      已使用:4次
      result is:3

      现在我们得到了同样的结果。(需要导入两个包,cglib-2.2.2.jar asm-3.3.jar)

      两种方法各有所长,JDK代理需要先设置一个接口,然后才能实现代理,这是它的缺点,也是它的优点,缺点是这样会麻烦一点,而且无法对那些已经封装好的,没有实现接口的类进行代理,而CGLib代理的方式不需要使用接口。但也正是因为如此,JDK代理的方式仅仅拦截类中覆盖接口的方法,而CGLib则会拦截类的所有方法调用。两者各有利弊,所以需要具体情况具体分析。在Spring中也是混杂使用了两种代理模式。

      以上就是本次介绍的Java电子书的全部相关内容,希望我们整理的资源能够帮助到大家,感谢大家对码农之家的支持。

      上一篇:云端时代杀手级应用:大数据分析

      下一篇:Java高手真经应用框架卷:Java Web核心框架

      查看更多
      读者心得
      85小时17分钟前回答

      你应该知道的21个Java核心技术

      写这篇文章的目的是想总结一下自己这么多年来使用java的一些心得体会,主要是和一些java基础知识点相关的,所以也希望能分享给刚刚入门的Java程序员和打算入Java开发这个行当的准新手们,希望可以给大家一些经验,能让大家更好学习和使用Java。 这次介绍的主要内容是和J2SE相关的部分,另外,会在以后再介绍些J2EE相关的、和Java中各个框架相关的内容。 经过这么多年的Java开发,以及结合平时面试Java开发者的一些经验,我觉得对于J2SE方面主要就是要掌握以下的一些内容。 1. JVM相关(包括了各个版本的特性) 对于刚刚接触Java的人来说,JVM相关的知识不一定需要理解很深,对此里面的概念有一些简单的……

      130小时3分钟前回答

      java核心编程之文件过滤类FileFilter和FilenameFilter

      本文实例为大家分享了文件过滤类FileFilter和FilenameFilter,供大家参考,具体内容如下 1.FileFilter package test;import java.io.File;import java.io.FileFilter;public class FileFilterTest implements FileFilter { private String extension; public FileFilterTest(String extension) { this.extension = extension; } /** * */ @Override public boolean accept(File pathname) { if(pathname.isDirectory()){ return false; } String name = pathname.getName(); int num = name.lastIndexOf("."); if(num == -1){ return false; } if(name.length()-1 == num){ return false; } else { return extension.equals(name.substring(num+1)); } } public static void main(String[] args) { File path = new File("E:\\书籍\\java 编程"); //获得过滤对象 FileFilterTest ft = new FileFilterTest("pdf"); File[……

      70小时50分钟前回答

      Java核心库实现AOP方法详解

      这篇文章是关于Java的一个疑难杂症,通过利用Java核心库实现简单的AOP方法,并把实例代码做了分析对照,以下是全部内容: Spring是一个十分火热开源框架,而AOP(面向切面编程)则是Spring最重要的概念之一,为了更好的理解和学习AOP的思想,使用核心库来实现一次不失为一个好方法。 首先介绍一下AOP的概念,AOP(Aspect Oriented Programming),即面向切面编程,所谓的面向切面编程,就是从一个横切面的角度去设计代码的思想,传统的OOP思想是用封装继承和多态构造一种纵向的层次关系,但不适合定义横向的关系,而AOP思想则对此进行了很好的补充。 例如日志管理代码往往横向的散布在很多对象层次中,……

      码农之家

      寿思淼 提供上传

      资源
      48
      粉丝
      7
      喜欢
      172
      评论
      16

      Copyright 2018-2021 www.xz577.com 码农之家

      版权投诉 / 书籍推广:520161757@qq.com