Posted in Spring, 技术

《Spring 3.X 企业应用开发实战》摘记 【持续更新】

Writer      :BYSocket(泥沙砖瓦浆木匠)

一、实战中的经验

注解相关

@Repository

标示一种作为单独在Model中使用的操作接口,没有封装的状态。

很常见的定义注解通过Spring定义Dao Bean。DAO(Data Access Object),项目中经常应用的数据库访问层可以使用该注释。但要注意和DDD(领域驱动设计)的区别。


@Service

表示一种作为服务类,也是一种特殊的@Component。


@Controller

标注一种是Controller层的类。也就是形象的Action层,我觉得Action更贴近生活点。因为我比较爱生活。和@Service一样一种特殊的@Component。


@Autowired

标注构造函数,字段,setter方法或配置方法,让其通过Spring依赖注入自动填充。

是否看过很常见的如下定义:在Action层自动注入service层Bean,可以字段也可以set方法,也就是说字段可以省了段代码(何乐而不为)。

那个配置方法,就是Java Config方法,比如说获取些主机名,端口号之类。


@RequestMapping

作用于类或者方法,用于映射Web请求。也就是一种在Servlet与Web组件之间的一种中庸之道吧。


二、配置

<context:component-scan base-package=”packagename.xxx”/>

扫描base-package下的包,将标注Spring注解(@Service、@Autowired、@Repository)的类自动转化为Bean,完成Bean的注入。比如DAO层,Service层的依赖注入。


事务配置及AOP配置提供事务增强:

<!-- ①配置事务管理器:负责声明式事务管理,引用了dataSource Bean -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>

<!-- ②通过AOP配置提供事务增强,让Service包下所有Bean的所有方法拥有事务 -->
<aop:config proxy-target-class="true">
<!-- ③AOP切入点 -->
<aop:pointcut id="serviceMethod" expression="execution(*projectpackage.service..*(..))"/>
<!-- ④Spring Advisor类似拦截器 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod"/>
</aop:config>
<!-- ⑤AOP通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="*"/>
</tx:attributes>
</tx:advice>

①处配置了transaction事务管理器,引用了dataSource 。其内在应该是把数据库事务用Spring(代码)级别声明式管理

②配了事务管理器,哪里用到了?当然要用的地方,比如Service层。利用AOP切面提供事务,使得事务得到打了鸡血式的使用。里面配置了③切入点(哪里用事务)及④利用Spring Advisor(类似拦截器)拦截至切入点,并引用⑤通知来正则匹配其Service方法来AOP,可以看出细粒度达到方法级别

三、持续更新。。。

欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

微         博:BYSocket  豆         瓣:BYSocket  FaceBook:BYSocket  Twitter    :BYSocket

c260f7abjw1ey2ostokgbj20hs0c876d

Posted in Java, 技术

初探设计:Java继承何时用?怎么用?

Writer      :BYSocket(泥沙砖瓦浆木匠)

一、回顾继承

常见的如下:

1、依赖(”uses-a“)

2、聚合(”has-a“)

3、继承(”is-a“)类之间关系

也就是UML类图中常见的三种关系,另外常见的还有实现(接口与实现类的关系),组合等。

 

继承,即“is-a”关系,是一种表示特殊与一般的关系。比如,女人(特殊)是一个人(一般)。关键字extends表明正在构造的新类派生于一个存在的类。

1、已经存在的类称为 超类父类或者基类

2、新类被称为 子类或者派生类

 

有时候看着人家源码的设计。比如常见的接口,紧接着抽象类实现接口,然后继承该抽象类的各种实现:

image

一般都是这样的,行为总则都写着顶层接口抽象类实现了下面各个实现类公用的方法和字段实现类各自实现功能

但里面这些究竟怎么用呢?比如继承在什么前提下使用,什么场景前提下,下面就是思考后的小结:(Think , Write & Do)

 

二、继承何时用?怎么用

也就是说,继承设计使用的时候,有哪些技巧,有哪些需要注意的地方。

1、公共的方法和字段才放在基类(也就是父类)

这句话可能有争议,太过于吹毛求兹或者是严格。拿女人和人的问题来说,比如名字字段、age都可以放在基类人上面,但女人的那些第二特征就是独有了。

但有些时候的例子总是很疑惑:比如Java工程师实习生和Java工程师,看样子可以“实习生”extends “Java工程师”,然后很多Java工程师上的字段都是不属于Java实习生的。顾两者并没有上面太大关系,可能都是从属于一个父类—工程师。下面类关系图才是正确的:

image

子类对父类的继承是包括了父类的公有和受保护的方法和字段。但子类只需要继承父类的一部分,就没辙了。这时候记住一句话:“多用组合,少用继承”。

 

2、protect并不能保护父类

其实protect机制在父类并不能起到好的保护。子类可以在需要的的时候访问父类。但是继承无限制,即子类的子类… 无止境的。如果想侵入父类protect方法,只需要写个类,继承任意子类就可访问。二者,同一个包下能访问。

 

从上面也可以总结出:

3、在继承父类的方法与字段都有意义的时候,选择继承。否则,不要使用继承。

 

4、在覆盖父类中的行为(方法)时,不要偏离最初的设计内涵。

父类的方法实现或者定义都是指定了一种行为的内涵。所以继承父类的时候,有个重写override)方法可以改变子类的行为。但请不要改变其定义的内涵。源码中常见的有:比如 IO 中的 read write方法和Servlet中 的 get post。

 

5、继承与组合、多态

继承,子类与父类在编译期就能确定其对象。而组合或者是多态,在运行期就才能确定其对象,相比之下,组合多态达到了更多的灵活性。但,运行期未知的错误是要注意处理的。

顾,“多用组合,少用继承”。

 

三、本文小结

继承的一点一滴。泥瓦匠,这软文小结,难免有错误。欢迎指正讨论。

欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

微         博:BYSocket  豆         瓣:BYSocket  FaceBook:BYSocket  Twitter    :BYSocket

7066956_21002167761444703497_thumb

Posted in Java, 技术

【Java模板语言】TinyTemplate 实战 <一>:Serlvet集成

Writer      :BYSocket(泥沙砖瓦浆木匠)

一、什么是TinyTemplate

什么是模板语言?

模板语言是为了使用户界面与业务数据(内容)分离而产生的,并能生成特定格式的文档。

什么是TinyTemplate?(开源项目地址入口

Tiny模板引擎是一个基于Java技术构建的模板引擎,它具有体量小、性能高和扩展易的特点。 适合于所有通过文本模板生成文本类型内容的场景,如:XML、源文件、HTML等等,可以说,它的出现就是为了替换Velocity模板引擎而来,因此在指令集上在尽量与Velocity接近的同时,又扩展了一些Velocity不能很好解决问题的指令与功能,在表达多方面则尽量与Java保持一致,所以非常地易学易用。

1. 体量小表现在总共不到5000多行的代码,去掉解析器近1000行,核心引擎只有4000多行代码。

2. 性能高表现在与现在国内几款高性能模板引擎如:Jetbrick、Webit等引擎的性能相比,近乎伯仲之间,但是比Velocity、Freemarker等则有长足的进步,效率大致是Velocity四倍。

3. 扩展性表现在Tiny框架引擎的所有环境都可以自行扩展,并与原有体系进行良好统一。

4. 易学习表现在Tiny框架概念清晰、模块划分科学、具有非常高的高内聚及低耦合。

5. 使用方式灵活表现在,可以多例方式、单例方式,并可以与Spring等有良好集成。

6. 友好的错误提示信息。


简要特点介绍:

1. 类似于 Velocity 的指令方式,相同或相似指令达90%左右

2. 支持可变参数方法调用

3. 支持类成员方法重载

4. 支持函数扩展

5. 采用弱类型方式,对于模板层的代码编写约束更小,模型层怎样变化,模板层的代码调整都非常容易

6. 支持宏定义#macro

7. 支持布局#layout

二、与Servlet集成,运行Hello,World

1. 新建一个quickstart.servlettemplate maven项目

在Eclipse中,new — Maven Project — “maven-archetype-quickstart“ …

在pom.xml添加对tinyTemplate的依赖:

    	<!-- 模板引擎对servlet的扩展依赖 -->
    	<dependency>
  			<groupId>org.tinygroup</groupId>
  			<artifactId>org.tinygroup.templateservletext</artifactId>
  			<version>2.0.26</version>
		</dependency>
如上代码,重写TinyServlet的handleRequest方法即可,然后在里面进行逻辑处理,return返回index.page。
4. 添加default.layout和index.page
default.layout:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
        "http://www.w3.org/TR/html4/strict.dtd">
<!--[if IE 7 ]>		 <html class="no-js ie ie7 lte7 lte8 lte9" lang="en-US"> <![endif]-->
<!--[if IE 8 ]>		 <html class="no-js ie ie8 lte8 lte9" lang="en-US"> <![endif]-->
<!--[if IE 9 ]>		 <html class="no-js ie ie9 lte9" lang="en-US"> <![endif]-->
<!--[if (gt IE 9)|!(IE)]><!-->
<html class="no-js" lang="en-US"> <!--<![endif]-->
<html lang="en">
<head>
    <meta charset="utf-8"/>
    <title>${pageTitle}</title>

    <script>
        var contextPath = "${TINY_CONTEXT_PATH}";
        var CKEDITOR_BASEPATH = contextPath+'/ckeditor/';

        /*
        jQuery.fn.outerHTML = function(s) {
            return (s) ? this.before(s).remove() : jQuery("p").append(this.eq(0).clone()).html();
        }
        */
    </script>


    <link rel="shortcut icon" href="${TINY_CONTEXT_PATH}/icon/logo.png">
    
 #if(DEBUG_MODE && DEBUG_MODE=="true")
	#foreach(component in uiengine.getHealthUiComponents())
	<!--UI component $component.name start -->
	#if(component.cssResource)
	#set(resources=component.cssResource.split(","))
	#foreach(path in resources)
	#set(path=path.trim())
	#set(newPath=path.replaceAll("[$][{]TINY_THEME[}]","${TINY_THEME}"))
	<link href="${TINY_CONTEXT_PATH}${newPath}" rel="stylesheet" />
	#end
	#end
	#if(component.jsResource)
	#set(resources=component.jsResource.split(","))
	#foreach(path in resources)
	#set(path=path.trim())
	<script src="${TINY_CONTEXT_PATH}${path}"></script>
	#end
	#end
	#if(component.jsCodelet)
	<script>
	$!{component.jsCodelet}
	</script>
	#end
	#if(component.cssCodelet)
	<style>
	$!{component.cssCodelet}
	</style>
	#end
	#end
 #else
  <link href="${TINY_CONTEXT_PATH}/uiengine.uicss" rel="stylesheet" />
  <script src="${TINY_CONTEXT_PATH}/uiengine.uijs"></script>
 #end
</head>
<body>
      #pageContent
</body>
</html>
index.page:
${name},欢迎来到Tiny的世界! 时间:${date}
5. 运行项目,右键项目 run as — maven build — “jetty:run”。访问 localhost:8080/项目名/index
image

三、小结

1、TinyTemplate的简介与特点

2、TinyTemplate与Servlet的配置(下一讲与SpringMVC的配置)

3、TinyTemplate最简单的也是最常用的取值语法${}

欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

微         博:BYSocket  豆         瓣:BYSocket  FaceBook:BYSocket  Twitter    :BYSocket

Posted in 清文

《赌客信条》小摘

全文有理有据,全文小例子,小情节,情节中得出结论。让人回味,让人学到一些所谓的行为经济学。

1、见好就收

2、让“试行办法”成为正式策略

    计划赶不上变化,不如先做着试试。试试十天半个月不妨。

3、大钱小花,小钱大花

    小事做起,要节约。

4、大数法则

    学会一些平均法则

5、小数法则

    心理误区,用于告诫自己

Posted in Java, 技术

深入浅出: Java回调机制(异步)

Writer      :BYSocket(泥沙砖瓦浆木匠)

什么是回调?今天傻傻地截了张图问了下,然后被陈大牛回答道“就一个回调…”。此时千万个草泥马飞奔而过(逃

哈哈,看着源码,享受着这种回调在代码上的作用,真是美哉。不妨总结总结。

一、什么是回调

回调,回调。要先有调用,才有调用者和被调用者之间的回调。所以在百度百科中是这样的:

软件模块之间总是存在着一定的接口,从调用方式上,可以把他们分为三类:同步调用、回调和异步调用

回调是一种特殊的调用,至于三种方式也有点不同。

1、同步回调,即阻塞,单向

2、回调,即双向(类似自行车的两个齿轮)。

3、异步调用,即通过异步消息进行通知。

 

二、CS中的异步回调(java案例)

比如这里模拟个场景:客户端发送msg给服务端,服务端处理后(5秒),回调给客户端,告知处理成功。代码如下:

回调接口类:

/**
 * @author Jeff Lee
 * @since 2015-10-21 21:34:21
 * 回调模式-回调接口类
 */
public interface CSCallBack {
    public void process(String status);
}

模拟客户端:

/**
 * @author Jeff Lee
 * @since 2015-10-21 21:25:14
 * 回调模式-模拟客户端类
 */
public class Client implements CSCallBack {

    private Server server;

    public Client(Server server) {
        this.server = server;
    }

    public void sendMsg(final String msg){
        System.out.println("客户端:发送的消息为:" + msg);
        new Thread(new Runnable() {
            @Override
            public void run() {
                server.getClientMsg(Client.this,msg);
            }
        }).start();
        System.out.println("客户端:异步发送成功");
    }

    @Override
    public void process(String status) {
        System.out.println("客户端:服务端回调状态为:" + status);
    }
}

模拟服务端:

/**
 * @author Jeff Lee
 * @since 2015-10-21 21:24:15
 * 回调模式-模拟服务端类
 */
public class Server {

    public void getClientMsg(CSCallBack csCallBack , String msg) {
        System.out.println("服务端:服务端接收到客户端发送的消息为:" + msg);

        // 模拟服务端需要对数据处理
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("服务端:数据处理成功,返回成功状态 200");
        String status = "200";
        csCallBack.process(status);
    }
}

测试类:

/**
 * @author Jeff Lee
 * @since 2015-10-21 21:24:15
 * 回调模式-测试类
 */
public class CallBackTest {
    public static void main(String[] args) {
        Server server = new Server();
        Client client = new Client(server);

        client.sendMsg("Server,Hello~");
    }
}

 

运行下测试类 — 打印结果如下:

客户端:发送的消息为:Server,Hello~
客户端:异步发送成功
服务端:服务端接收到客户端发送的消息为:Server,Hello~

(这里模拟服务端对数据处理时间,等待5秒)
服务端:数据处理成功,返回成功状态 200
客户端:服务端回调状态为:200

一步一步分析下代码,核心总结如下

1、接口作为方法参数,其实际传入引用指向的是实现类

2、Client的sendMsg方法中,参数final,因为要被内部类一个新的线程可以使用。这里就体现了异步

3、调用server的getClientMsg(),参数传入了Client本身(对应第一点)。

 

还有值得一提的是(逃

— 开源代码都在我的gitHub哦~

 

三、回调的应用场景

回调目前运用在什么场景比较多呢?从操作系统开发者调用

1、Windows平台的消息机制

2、异步调用微信接口,根据微信返回状态对出业务逻辑响应。

3、Servlet中的Filter(过滤器)是基于回调函数,需容器支持。

补充:其中 Filter(过滤器)和Interceptor(拦截器)的区别,拦截器基于是Java的反射机制,和容器无关。但与回调机制有异曲同工之妙。

总之,这设计让底层代码调用高层定义(实现层)的子程序,增强了程序的灵活性。

 

四、模式对比

上面讲了Filter和Intercepter有着异曲同工之妙。其实接口回调机制和一种设计模式—观察者模式也有相似之处:

观察者模式

GOF说道 — “定义对象的一种一对多的依赖关系,当一个对象的状态发送改变的时候,所有对他依赖的对象都被通知到并更新。”它是一种模式,是通过接口回调的方法实现的,即它是一种回调的体现。

接口回调

与观察者模式的区别是,它是种原理,而非具体实现。


五、心得

总结四步走:

机制,即是原理。

模式,即是体现。

记住具体场景,常见模式。

然后深入理解原理。

欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

微         博:BYSocket  豆         瓣:BYSocket  FaceBook:BYSocket  Twitter    :BYSocket

Posted in Java, 技术

深入浅出: 大小端模式

Writer      :BYSocket(泥沙砖瓦浆木匠)

一、什么大小端?

大小端在计算机业界,Endian表示数据在存储器中的存放顺序。百度百科如下叙述之:

大端模式,是指数据的高字节保存在内存的低地址中,而数据的低字节保存在内存的高地址中,这样的存储模式有点儿类似于把数据当作字符串顺序处理:地址由小向大增加,而数据从高位往低位放;

小端模式,是指数据的高字节保存在内存的高地址中,而数据的低字节保存在内存的低地址中,这种存储模式将地址的高低和数据位权有效地结合起来,高地址部分权值高,低地址部分权值低,和我们的逻辑方法一致。

这两种模式,泥瓦匠记忆宫殿:“小端低低”。这样就知道小端的模式,反之大端的模式。

比如整形十进制数字:305419896 ,转化为十六进制表示 : 0x12345678 。其中按着十六进制的话,每两位占8个位,及一个字节。如图

iostream

二、为什么有大小端模式之分呢?

如果统一使用大端或者小端,那么何来三国演义,何来一战二战呢?还有大小端也来源于战争。所以存在即是合理。

在操作系统中,x86和一般的OS(如windows,FreeBSD,Linux)使用的是小端模式。但比如Mac OS是大端模式。

在计算机系统中,我们是以字节为单位的,每个地址单元都对应着一个字节,一个字节为8bit。但是在C语言中除了8bit的char之外,还有16bit的short型,32bit的long型(要看具体的编译器)。另外,对于位数大于8位的处理器,例如16位或者32位的处理器,由于寄存器宽度大于一个字节,那么必然存在着一个如果将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。

 

知道为什么有模式的存在,下面需要了解下具有有什么应用场景

1、不同端模式的处理器进行数据传递时必须要考虑端模式的不同

2、在网络上传输数据时,由于数据传输的两端对应不同的硬件平台,采用的存储字节顺序可能不一致。所以在TCP/IP协议规定了在网络上必须采用网络字节顺序,也就是大端模式。对于char型数据只占一个字节,无所谓大端和小端。而对于非char类型数据,必须在数据发送到网络上之前将其转换成大端模式。接收网络数据时按符合接受主机的环境接收。

 

三、java中的大小端

存储量大于1字节,非char类型,如int,float等,要考虑字节的顺序问题了。java由于虚拟机的关系,屏蔽了大小端问题,需要知道的话可用 ByteOrder.nativeOrder() 查询。在操作ByteBuffer中,也可以使用 ByteBuffer.order() 进行设置:

/**
 * @author Jeff Lee
 * @since 2015-10-13 20:40:00
 * ByteBuffer中字节存储次序
 */
public class Endians {
    public static void main(String[] args) {
        // 创建12个字节的字节缓冲区
        ByteBuffer bb = ByteBuffer.wrap(new byte[12]);
        // 存入字符串
        bb.asCharBuffer().put("abdcef");
        System.out.println(Arrays.toString(bb.array()));

        // 反转缓冲区
        bb.rewind();
        // 设置字节存储次序
        bb.order(ByteOrder.BIG_ENDIAN);
        bb.asCharBuffer().put("abcdef");
        System.out.println(Arrays.toString(bb.array()));

        // 反转缓冲区
        bb.rewind();
        // 设置字节存储次序
        bb.order(ByteOrder.LITTLE_ENDIAN);
        bb.asCharBuffer().put("abcdef");
        System.out.println(Arrays.toString(bb.array()));
    }
}

run下结果如图所示:

image

前两句打印说明了,ByteBuffer存储字节次序默认为大端模式。最后一段设置了字节存储次序,然后会输出,可以看出存储次序为小端模式。

 

欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

微         博:BYSocket  豆         瓣:BYSocket  FaceBook:BYSocket  Twitter    :BYSocket

Posted in Java, 技术

Java IO 之 FileInputStream & FileOutputStream源码分析

Writer      :BYSocket(泥沙砖瓦浆木匠)

微         博:BYSocket

豆         瓣:BYSocket

FaceBook:BYSocket

Twitter    :BYSocket

一、引子

文件,作为常见的数据源。关于操作文件的字节流就是 — FileInputStream & FileOutputStream。它们是Basic IO字节流中重要的实现类。

 

二、FileInputStream源码分析

FileInputStream源码如下:

/**
 * FileInputStream 从文件系统的文件中获取输入字节流。文件取决于主机系统。
 * 	比如读取图片等的原始字节流。如果读取字符流,考虑使用 FiLeReader。
 */
public class SFileInputStream extends InputStream
{
    /* 文件描述符类---此处用于打开文件的句柄 */
    private final FileDescriptor fd;

    /* 引用文件的路径 */
    private final String path;

    /* 文件通道,NIO部分 */
    private FileChannel channel = null;

    private final Object closeLock = new Object();
    private volatile boolean closed = false;

    private static final ThreadLocal<Boolean> runningFinalize =
        new ThreadLocal<>();

    private static boolean isRunningFinalize() {
        Boolean val;
        if ((val = runningFinalize.get()) != null)
            return val.booleanValue();
        return false;
    }

    /* 通过文件路径名来创建FileInputStream */
    public FileInputStream(String name) throws FileNotFoundException {
        this(name != null ? new File(name) : null);
    }

    /* 通过文件来创建FileInputStream */
    public FileInputStream(File file) throws FileNotFoundException {
        String name = (file != null ? file.getPath() : null);
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(name);
        }
        if (name == null) {
            throw new NullPointerException();
        }
        if (file.isInvalid()) {
            throw new FileNotFoundException("Invalid file path");
        }
        fd = new FileDescriptor();
        fd.incrementAndGetUseCount();
        this.path = name;
        open(name);
    }

    /* 通过文件描述符类来创建FileInputStream */
    public FileInputStream(FileDescriptor fdObj) {
        SecurityManager security = System.getSecurityManager();
        if (fdObj == null) {
            throw new NullPointerException();
        }
        if (security != null) {
            security.checkRead(fdObj);
        }
        fd = fdObj;
        path = null;
        fd.incrementAndGetUseCount();
    }

    /* 打开文件,为了下一步读取文件内容。native方法 */
    private native void open(String name) throws FileNotFoundException;

    /* 从此输入流中读取一个数据字节 */
    public int read() throws IOException {
        Object traceContext = IoTrace.fileReadBegin(path);
        int b = 0;
        try {
            b = read0();
        } finally {
            IoTrace.fileReadEnd(traceContext, b == -1 ? 0 : 1);
        }
        return b;
    }

    /* 从此输入流中读取一个数据字节。native方法 */
    private native int read0() throws IOException;

    /* 从此输入流中读取多个字节到byte数组中。native方法 */
    private native int readBytes(byte b[], int off, int len) throws IOException;

    /* 从此输入流中读取多个字节到byte数组中。 */
    public int read(byte b[]) throws IOException {
        Object traceContext = IoTrace.fileReadBegin(path);
        int bytesRead = 0;
        try {
            bytesRead = readBytes(b, 0, b.length);
        } finally {
            IoTrace.fileReadEnd(traceContext, bytesRead == -1 ? 0 : bytesRead);
        }
        return bytesRead;
    }

    /* 从此输入流中读取最多len个字节到byte数组中。 */
    public int read(byte b[], int off, int len) throws IOException {
        Object traceContext = IoTrace.fileReadBegin(path);
        int bytesRead = 0;
        try {
            bytesRead = readBytes(b, off, len);
        } finally {
            IoTrace.fileReadEnd(traceContext, bytesRead == -1 ? 0 : bytesRead);
        }
        return bytesRead;
    }

    
    public native long skip(long n) throws IOException;

    /* 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取(或跳过)的估计剩余字节数。 */
    public native int available() throws IOException;

    /* 关闭此文件输入流并释放与此流有关的所有系统资源。 */
    public void close() throws IOException {
        synchronized (closeLock) {
            if (closed) {
                return;
            }
            closed = true;
        }
        if (channel != null) {
           fd.decrementAndGetUseCount();
           channel.close();
        }

        int useCount = fd.decrementAndGetUseCount();

        if ((useCount <= 0) || !isRunningFinalize()) {
            close0();
        }
    }

    public final FileDescriptor getFD() throws IOException {
        if (fd != null) return fd;
        throw new IOException();
    }

    /* 获取此文件输入流的唯一FileChannel对象 */
    public FileChannel getChannel() {
        synchronized (this) {
            if (channel == null) {
                channel = FileChannelImpl.open(fd, path, true, false, this);
                fd.incrementAndGetUseCount();
            }
            return channel;
        }
    }

    private static native void initIDs();

    private native void close0() throws IOException;

    static {
        initIDs();
    }

    protected void finalize() throws IOException {
        if ((fd != null) &&  (fd != FileDescriptor.in)) {
            runningFinalize.set(Boolean.TRUE);
            try {
                close();
            } finally {
                runningFinalize.set(Boolean.FALSE);
            }
        }
    }
}

1. 三个核心方法

三个核心方法,也就是Override(重写)了抽象类InputStreamread方法。

int read() 方法,即

public int read() throws IOException

代码实现中很简单,一个try中调用本地nativeread0()方法,直接从文件输入流中读取一个字节。IoTrace.fileReadEnd(),字面意思是防止文件没有关闭读的通道,导致读文件失败,一直开着读的通道,会造成内存泄露。

 

int read(byte b[]) 方法,即

public int read(byte b[]) throws IOException

代码实现也是比较简单的,也是一个try中调用本地nativereadBytes()方法,直接从文件输入流中读取最多b.length个字节到byte数组b中。

 

int read(byte b[], int off, int len) 方法,即

public int read(byte b[], int off, int len) throws IOException

代码实现和 int read(byte b[])方法 一样,直接从文件输入流中读取最多len个字节到byte数组b中。

可是这里有个问答:

Q: 为什么 int read(byte b[]) 方法需要自己独立实现呢? 直接调用 int read(byte b[], int off, int len) 方法,即read(b , 0 , b.length),等价于read(b)?

A:待完善,希望路过大神回答。。。。向下兼容?? Finally??

 

2. 值得一提的native方法

上面核心方法中为什么实现简单,因为工作量都在native方法里面,即JVM里面实现了。native倒是不少一一列举吧:

native void open(String name) // 打开文件,为了下一步读取文件内容

native int read0() // 从文件输入流中读取一个字节

native int readBytes(byte b[], int off, int len) // 从文件输入流中读取,从off句柄开始的len个字节,并存储至b字节数组内。

native void close0() // 关闭该文件输入流及涉及的资源,比如说如果该文件输入流的FileChannel对被获取后,需要对FileChannel进行close。

 

其他还有值得一提的就是,在jdk1.4中,新增了NIO包,优化了一些IO处理的速度,所以在FileInputStream和FileOutputStream中新增了FileChannel getChannel()的方法。即获取与该文件输入流相关的 java.nio.channels.FileChannel对象。

 

三、FileOutputStream 源码分析

FileOutputStream 源码如下:

/**
 * 文件输入流是用于将数据写入文件或者文件描述符类
 * 	比如写入图片等的原始字节流。如果写入字符流,考虑使用 FiLeWriter。
 */
public class SFileOutputStream extends OutputStream
{
    /* 文件描述符类---此处用于打开文件的句柄 */
    private final FileDescriptor fd;

    /* 引用文件的路径 */
    private final String path;

    /* 如果为 true,则将字节写入文件末尾处,而不是写入文件开始处 */
    private final boolean append;

    /* 关联的FileChannel类,懒加载 */
    private FileChannel channel;

    private final Object closeLock = new Object();
    private volatile boolean closed = false;
    private static final ThreadLocal<Boolean> runningFinalize =
        new ThreadLocal<>();

    private static boolean isRunningFinalize() {
        Boolean val;
        if ((val = runningFinalize.get()) != null)
            return val.booleanValue();
        return false;
    }

    /* 通过文件名创建文件输入流 */
    public FileOutputStream(String name) throws FileNotFoundException {
        this(name != null ? new File(name) : null, false);
    }

    /* 通过文件名创建文件输入流,并确定文件写入起始处模式 */
    public FileOutputStream(String name, boolean append)
        throws FileNotFoundException
    {
        this(name != null ? new File(name) : null, append);
    }

    /* 通过文件创建文件输入流,默认写入文件的开始处 */
    public FileOutputStream(File file) throws FileNotFoundException {
        this(file, false);
    }

    /* 通过文件创建文件输入流,并确定文件写入起始处  */
    public FileOutputStream(File file, boolean append)
        throws FileNotFoundException
    {
        String name = (file != null ? file.getPath() : null);
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkWrite(name);
        }
        if (name == null) {
            throw new NullPointerException();
        }
        if (file.isInvalid()) {
            throw new FileNotFoundException("Invalid file path");
        }
        this.fd = new FileDescriptor();
        this.append = append;
        this.path = name;
        fd.incrementAndGetUseCount();
        open(name, append);
    }

    /* 通过文件描述符类创建文件输入流 */
    public FileOutputStream(FileDescriptor fdObj) {
        SecurityManager security = System.getSecurityManager();
        if (fdObj == null) {
            throw new NullPointerException();
        }
        if (security != null) {
            security.checkWrite(fdObj);
        }
        this.fd = fdObj;
        this.path = null;
        this.append = false;

        fd.incrementAndGetUseCount();
    }

    /* 打开文件,并确定文件写入起始处模式 */
    private native void open(String name, boolean append)
        throws FileNotFoundException;

    /* 将指定的字节b写入到该文件输入流,并指定文件写入起始处模式 */
    private native void write(int b, boolean append) throws IOException;

    /* 将指定的字节b写入到该文件输入流 */
    public void write(int b) throws IOException {
        Object traceContext = IoTrace.fileWriteBegin(path);
        int bytesWritten = 0;
        try {
            write(b, append);
            bytesWritten = 1;
        } finally {
            IoTrace.fileWriteEnd(traceContext, bytesWritten);
        }
    }

    /* 将指定的字节数组写入该文件输入流,并指定文件写入起始处模式 */
    private native void writeBytes(byte b[], int off, int len, boolean append)
        throws IOException;

    /* 将指定的字节数组b写入该文件输入流 */
    public void write(byte b[]) throws IOException {
        Object traceContext = IoTrace.fileWriteBegin(path);
        int bytesWritten = 0;
        try {
            writeBytes(b, 0, b.length, append);
            bytesWritten = b.length;
        } finally {
            IoTrace.fileWriteEnd(traceContext, bytesWritten);
        }
    }

    /* 将指定len长度的字节数组b写入该文件输入流 */
    public void write(byte b[], int off, int len) throws IOException {
        Object traceContext = IoTrace.fileWriteBegin(path);
        int bytesWritten = 0;
        try {
            writeBytes(b, off, len, append);
            bytesWritten = len;
        } finally {
            IoTrace.fileWriteEnd(traceContext, bytesWritten);
        }
    }

    /* 关闭此文件输出流并释放与此流有关的所有系统资源 */
    public void close() throws IOException {
        synchronized (closeLock) {
            if (closed) {
                return;
            }
            closed = true;
        }

        if (channel != null) {
            fd.decrementAndGetUseCount();
            channel.close();
        }

        int useCount = fd.decrementAndGetUseCount();

        if ((useCount <= 0) || !isRunningFinalize()) {
            close0();
        }
    }

     public final FileDescriptor getFD()  throws IOException {
        if (fd != null) return fd;
        throw new IOException();
     }

    public FileChannel getChannel() {
        synchronized (this) {
            if (channel == null) {
                channel = FileChannelImpl.open(fd, path, false, true, append, this);

                fd.incrementAndGetUseCount();
            }
            return channel;
        }
    }

    protected void finalize() throws IOException {
        if (fd != null) {
            if (fd == FileDescriptor.out || fd == FileDescriptor.err) {
                flush();
            } else {

                runningFinalize.set(Boolean.TRUE);
                try {
                    close();
                } finally {
                    runningFinalize.set(Boolean.FALSE);
                }
            }
        }
    }

    private native void close0() throws IOException;

    private static native void initIDs();

    static {
        initIDs();
    }

}

1. 三个核心方法

三个核心方法,也就是Override(重写)了抽象类OutputStreamwrite方法。

void write(int b) 方法,即

public void write(int b) throws IOException

代码实现中很简单,一个try中调用本地nativewrite()方法,直接将指定的字节b写入文件输出流。IoTrace.fileReadEnd()的意思和上面FileInputStream意思一致。

 

void write(byte b[]) 方法,即

public void write(byte b[]) throws IOException

代码实现也是比较简单的,也是一个try中调用本地nativewriteBytes()方法,直接将指定的字节数组写入该文件输入流。

 

void write(byte b[], int off, int len) 方法,即

public void write(byte b[], int off, int len) throws IOException

代码实现和 void write(byte b[]) 方法 一样,直接将指定的字节数组写入该文件输入流。

 

2. 值得一提的native方法

上面核心方法中为什么实现简单,因为工作量都在native方法里面,即JVM里面实现了。native倒是不少一一列举吧:

native void open(String name) // 打开文件,为了下一步读取文件内容

native void write(int b, boolean append) // 直接将指定的字节b写入文件输出流

native native void writeBytes(byte b[], int off, int len, boolean append) // 直接将指定的字节数组写入该文件输入流。

native void close0() // 关闭该文件输入流及涉及的资源,比如说如果该文件输入流的FileChannel对被获取后,需要对FileChannel进行close。

 

相似之处

其实到这里,该想一想。两个源码实现很相似,而且native方法也很相似。其实不能说“相似”,应该以“对应”来概括它们。

它们是一组,是一根吸管的两个孔的关系:“一个Input一个Output”。

 

休息一下吧~ 看看小广告:

开源代码都在我的gitHub上哦 — https://github.com/JeffLi1993 作者留言“请手贱,点项目star,支持支持拜托拜托”

 

四、使用案例

下面先看代码:

package org.javacore.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * Copyright [2015] [Jeff Lee]
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * @author Jeff Lee
 * @since 2015-10-8 20:06:03
 * FileInputStream&FileOutputStream使用案例
 */
public class FileIOStreamT {
	private static final String thisFilePath = 
			"src" + File.separator +
			"org" + File.separator +
			"javacore" + File.separator +
			"io" + File.separator +
			"FileIOStreamT.java";
	public static void main(String[] args) throws IOException {
		// 创建文件输入流
		FileInputStream fileInputStream = new FileInputStream(thisFilePath);
		// 创建文件输出流
		FileOutputStream fileOutputStream =  new FileOutputStream("data.txt");
		
		// 创建流的最大字节数组
		byte[] inOutBytes = new byte[fileInputStream.available()];
		// 将文件输入流读取,保存至inOutBytes数组
		fileInputStream.read(inOutBytes);
		// 将inOutBytes数组,写出到data.txt文件中
		fileOutputStream.write(inOutBytes);
		
		fileOutputStream.close();
		fileInputStream.close();
	}
}

运行后,会发现根目录中出现了一个“data.txt”文件,内容为上面的代码。

1. 简单地分析下源码:

1、创建了FileInputStream,读取该代码文件为文件输入流。

2、创建了FileOutputStream,作为文件输出流,输出至data.txt文件。

3、针对流的字节数组,一个 read ,一个write,完成读取和写入。

4、关闭流

2. 代码调用的流程如图所示:

iostream

3. 代码虽简单,但是有点小问题

FileInputStream.available() 是返回流中的估计剩余字节数。所以一般不会用此方法。

一般做法,比如创建一个 byte数组,大小1K。然后read至其返回值不为-1,一直读取即可。边读边写。

 

五、思考与小结

FileInputStream & FileOutputStream 是一对来自 InputStream和OutputStream的实现类。用于本地文件读写(二进制格式按顺序读写)

本文小结:

1、FileInputStream 源码分析

2、FileOutputStream 资源分析

3、FileInputStream & FileOutputStream 使用案例

4、其源码调用过程

欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

Posted in Java, 技术

Java IO 之 OutputStream源码

Writer      :BYSocket(泥沙砖瓦浆木匠)

微         博:BYSocket

豆         瓣:BYSocket

FaceBook:BYSocket

Twitter    :BYSocket

一、前言

上一篇《Java IO 之 InputStream源码》,说了InputStream。JDK1.0中就有了这传统的IO字节流,也就是 InputStream 和 OutputStream。梳理下两者的核心:

InputStream中有几个 read() 方法和 OutputStream中有几个 write() 方法。它们是一一对应的,而核心的是read()和write()方法。它们都没实现,所有本质调用是各自实现类实现的该两个方法。

read() 和 write() ,对应着系统的Input和Output,即系统的输出输入。

 

二、OutputStream

也是一个抽象类,即表示所有字节输入流实现类的基类。它的作用就是抽象地表示所有要输出到的目标,例如常见的FileOutStream、FilterOutputStream等。它实现了java.io.Closeable和java.io.Flushable两个接口。其中空实现了flush方法,即拥有刷新缓存区字节数组作用。

那些输出目标呢?比如:

1) 字节数组(不代表String类,但可以转换)

2) 文件

3) 管道(多线程环境中的数据源)

等等

FilterOutputStream是为各种OutputStream实现类提供的“装饰器模式”的基类。将属性或者有用的接口与输出流连接起来。

 

三、细解OutputStream源码的核心

一样的,先看源码:

/**
 * 所有字节输出流实现类的基类
 */
public abstract class SOutputStream implements Closeable, Flushable {

    // 将指定的字节写入输出流
    public abstract void write(int b) throws IOException;

    // 将指定的byte数组的字节全部写入输出流
    public void write(byte b[]) throws IOException {
        write(b, 0, b.length);
    }

    // 将指定的byte数组中从偏移量off开始的len个字节写入输出流
    public void write(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if ((off < 0) || (off > b.length) || (len < 0) ||
                   ((off + len) > b.length) || ((off + len) < 0)) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return;
        }
        for (int i = 0 ; i < len ; i++) {
            write(b[off + i]);
        }
    }

    // 刷新输出流,并强制写出所有缓冲的输出字节
    public void flush() throws IOException {
    }

    // 关闭输出流,并释放与该流有关的所有资源
    public void close() throws IOException {
    }

}

其中三个核心的write()方法,对应着三个InputStream的read()方法:

1. abstract void write(int b) 抽象方法

public abstract void write(int b) throws IOException;

对应着,InputStream的read()方法,此方法依旧是抽象方法。因为子类必须实现此方法的一个实现。这就是输入流的关键方法。

二者,下面两个write方法中调用了此核心方法。

可见,核心的是read()和write()方法在传统的IO是多么重要。

 

2.  void write(byte b[]) 方法

public void write(byte b[]) throws IOException

将指定的byte数组的字节全部写入输出流。该效果实际上是由下一个write方法实现的,只是调用的额时候指定了长度:

 

3.  void write(byte b[], int off, int len) 方法

public void write(byte b[], int off, int len) throws IOException

将指定的byte数组中从偏移量off开始的len个字节写入输出流。代码详细流程解读如下:

    a.  如果 bnull,则抛出 NullPointerException

b.  如果 off 为负,或 len 为负,或者 off+len 大于数组 b 的长度,则抛出 IndexOutOfBoundsException

c.  将数组 b 中的某些字节按顺序写入输出流;元素 b[off] 是此操作写入的第一个字节,b[off+len-1] 是此操作写入的最后一个字节。

四、小结

重要的事情说三遍:

OutputStream 解读对照着 InputStream来看!注意 一个write对应一个read

OutputStream 解读对照着 InputStream来看!注意 一个write对应一个read

OutputStream 解读对照着 InputStream来看!注意 一个write对应一个read

Posted in Java, 技术

Java IO 之 InputStream源码

 

Writer      :BYSocket(泥沙砖瓦浆木匠)

微         博:BYSocket

豆         瓣:BYSocket

FaceBook:BYSocket

Twitter    :BYSocket

一、InputStream

InputStream是一个抽象类,即表示所有字节输入流实现类的基类。它的作用就是抽象地表示所有从不同数据源产生输入的类,例如常见的FileInputStream、FilterInputStream等。那些数据源呢?比如:

1) 字节数组(不代表String类,但可以转换)

2) String对象

3) 文件

4) 一个其他种类的流组成的序列化 (在分布式系统中常见)

5) 管道(多线程环境中的数据源)

等等

二者,注意它是属于字节流部分,而不是字符流(java.io中Reader\Writer,下面会讲到)。

FilterInputStream是为各种InputStream实现类提供的“装饰器模式”的基类。因此,可以分为原始的字节流和“装饰”过的功能封装字节流。

 

二、细解InputStream源码的核心

源码如下:

/**
 * 所有字节输入流实现类的基类
 */
public abstract class SInputStream {

    // 缓存区字节数组最大值
    private static final int MAX_SKIP_BUFFER_SIZE = 2048;

    // 从输入流中读取数据的下一个字节,以int返回
    public abstract int read() throws IOException;

    // 从输入流中读取数据的一定数量字节,并存储在缓存数组b
    public int read(byte b[]) throws IOException {
        return read(b, 0, b.length);
    }

    // 从输入流中读取数据最多len个字节,并存储在缓存数组b
    public int read(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }

        int c = read();
        if (c == -1) {
            return -1;
        }
        b[off] = (byte)c;

        int i = 1;
        try {
            for (; i < len ; i++) {
                c = read();
                if (c == -1) {
                    break;
                }
                b[off + i] = (byte)c;
            }
        } catch (IOException ee) {
        }
        return i;
    }

    // 跳过输入流中数据的n个字节
    public long skip(long n) throws IOException {

        long remaining = n;
        int nr;

        if (n <= 0) {
            return 0;
        }

        int size = (int)Math.min(MAX_SKIP_BUFFER_SIZE, remaining);
        byte[] skipBuffer = new byte[size];
        while (remaining > 0) {
            nr = read(skipBuffer, 0, (int)Math.min(size, remaining));
            if (nr < 0) {
                break;
            }
            remaining -= nr;
        }

        return n - remaining;
    }

    // 返回下一个方法调用能不受阻塞地从此读取(或者跳过)的估计字节数
    public int available() throws IOException {
        return 0;
    }

    // 关闭此输入流,并释放与其关联的所有资源

    public void close() throws IOException {}

    // 在此输出流中标记当前位置
    public synchronized void mark(int readlimit) {}

    // 将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。
    public synchronized void reset() throws IOException {
        throw new IOException("mark/reset not supported");
    }

    // 测试此输入流是否支持 mark 和 reset 方法
    public boolean markSupported() {
        return false;
    }

}

其中,InputStream下面三个read方法才是核心方法:

public abstract int read()

抽象方法,没有具体实现。因为子类必须实现此方法的一个实现。这就是输入流的关键方法。

二者,可见下面两个read()方法都调用了这个方法子类的实现来完成功能的。

 

public int read(byte b[])

该方法是表示从输入流中读取数据的一定数量字节,并存储在缓存字节数组b。其效果等同于调用了下面方法的实现:

 read(b, 0, b.length)

如果b的长度为 0,则不读取任何字节并返回 0;否则,尝试读取至少 1 字节。如果因为流位于文件末尾而没有可用的字节,则返回值 -1;否则,至少读取一个字节并将其存储在 b 中。

思考:这时候,怪不得很多时候, b != –1 或者 b != EOF

 

public int read(byte b[], int off, int len)


在输入数据可用、检测到流末尾或者抛出异常前,此方法一直阻塞。

该方法先进行校验,然后校验下个字节是否为空。如果校验通过后,
如下代码:

int i = 1;
try {
    for (; i < len ; i++) {
        c = read();
        if (c == -1) {
            break;
        }
        b[off + i] = (byte)c;
    }
} catch (IOException ee) {
}

将读取的第一个字节存储在元素 b[off] 中,下一个存储在 b[off+1] 中,依次类推。读取的字节数最多等于 len。设 k 为实际读取的字节数;这些字节将存储在 b[off]b[off+k-1] 的元素中,不影响 b[off+k]b[off+len-1] 的元素。

因为有上面两个read的实现,所以这里InputStream设计为抽象类。

三、小结

1. InputSream 对应着 OutputStream

2. 看源码是享受人家写代码中流露的How

3. 泥瓦匠学习的代码都在github上(同步osc git),欢迎大家点star,提意见,一起进步。地址:https://github.com/JeffLi1993