异常管理 - 采用模板方法优化try-catch-finally

最新推荐文章于 2021-08-06 20:24:42 发布
最新推荐文章于 2021-08-06 20:24:42 发布
阅读量2.7k 收藏 3
点赞数
分类专栏： java 文章标签： 异常 java 优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piaohai/article/details/50392099
版权

Java 处理异常的语句try-catch-finally应该大家都不陌生, 程序中很多地方都会使用到, 比如IO操作, 对文件的读写, 数据库读写等, 另外事务处理也会用到, 在try块中处理逻辑, catch中回滚事务 ,finally中提交事务, 举个例子:

FileReadDemo.java

public class FileReadDemo {
	public void readFile() throws IOException {
		byte[] buff = new byte[1024];
		FileInputStream input = null;
		try {
			input = new FileInputStream(new File("D:/test/itart.txt"));
			while (-1 != input.read(buff)) {
				System.out.println(new String(buff));
			}
		} catch (IOException e) {
			throw e;
		} finally {
			if (null != input) {
				try {
					input.close();
				} catch (IOException e) {
					throw e;
				}
			}
		}
	}

	public static void main(String[] args) {
		try {
			new FileReadDemo().readFile();
		} catch (IOException e) {
			e.printStackTrace();
		}

	}
}

注意: 上面的例子实际上存在异常丢失的隐患, 如果第一个try中出现异常, 接着在执行finally中的input.close()也出现异常, 这时main 方法只能接收到input.close的异常信息, 第一个异常会被覆盖, 导致异常信息丢失, 详见: try-catch-finally异常信息丢失 

所以正确的写法如下:

public class FileReadDemo {
	public void readFile() throws ApplicationException {
		byte[] buff = new byte[1024];
		IOException processException = null;
		FileInputStream input = null;
		try {
			input = new FileInputStream(new File("D:/test/itart.txt"));
			while (-1 != input.read(buff)) {
				System.out.println(new String(buff));
			}
		} catch (IOException e) {
			processException = e;
		} finally {
			try {
				if(null != input){
					input.close();
				}
			} catch (IOException e) {
				if(null == processException){
					throw new ApplicationException(e);
				}else{
					throw new ApplicationException("FileInputStream close exception", processException);
				}
			}
			if(processException !=null){
				throw new ApplicationException(processException);
			}
		}
		
	}

	public static void main(String[] args){
		try {
			new FileReadDemo().readFile();
		} catch (ApplicationException e) {
			e.printStackTrace();
		}
		
	}
}

这种写法是不是很糟糕, 我们实际关注的代码就只是第一个try中的四行代码, 这样的缺陷很明显, 一旦系统中有多处地方要用到类似的文件处理操作时, 就需要重复的做try-catch-finally, 很明显, 这就违背了程序开发中的一个重要原则: DRY(Don’t repeat yourself), 代码重复, 不容易阅读和维护, 同时也存在一个隐患, 忘记关闭, 异常没正确处理等, 引入模板方法就可以很好的解决这个问题.

咱们先对代码进行重构, 剥离业务代码和异常处理代码.

public class FileReadDemo {
	public void readFile(String path) throws ApplicationException {

		IOException processException = null;
		FileInputStream input = null;
		try {
			input = new FileInputStream(new File(path));
			process(input);
		} catch (IOException e) {
			processException = e;
		} finally {
			try {
				if (null != input) {
					input.close();
				}
			} catch (IOException e) {
				if (null == processException) {
					throw new ApplicationException(e);
				} else {
					throw new ApplicationException(
							"FileInputStream close exception", processException);
				}
			}
			if (processException != null) {
				throw new ApplicationException(processException);
			}
		}

	}

	public void process(FileInputStream input) throws IOException {
		byte[] buff = new byte[1024];
		while (-1 != input.read(buff)) {
			System.out.println(new String(buff));
		}
	}

	public static void main(String[] args) {
		try {
			new FileReadDemo().readFile("D:/test/itart.txt");
		} catch (ApplicationException e) {
			e.printStackTrace();
		}

	}
}

可以看到, 在实际项目中每个功能对文件处理的差异地方就只有process方法, readFile中的异常处理是都一样的, 所以可以将readFile当成模板方法可以重复使用, process定义为抽象类, 由具体代码实现, 这样代码就可以变为: 

public abstract class FileReadDemo {
	public void readFile(String path) throws ApplicationException {

		IOException processException = null;
		FileInputStream input = null;
		try {
			input = new FileInputStream(new File(path));
			process(input);
		} catch (IOException e) {
			processException = e;
		} finally {
			try {
				if (null != input) {
					input.close();
				}
			} catch (IOException e) {
				if (null == processException) {
					throw new ApplicationException(e);
				} else {
					throw new ApplicationException(
							"FileInputStream close exception", processException);
				}
			}
			if (processException != null) {
				throw new ApplicationException(processException);
			}
		}

	}

	public abstract void process(FileInputStream input) throws IOException;

	public static void main(String[] args) {
		try {
			new FileReadDemo() {
				@Override
				public void process(FileInputStream input) throws IOException {
					byte[] buff = new byte[1024];
					while (-1 != input.read(buff)) {
						System.out.println(new String(buff));
					}
				}
			}.readFile("D:/test/itart.txt");
		} catch (ApplicationException e) {
			e.printStackTrace();
		}

	}
}

  • 最后分离模板, 整理效果如下:

模板类: FileInputStreamTemplate.java

public abstract class FileInputStreamTemplate {
	public void readFile(String path) throws ApplicationException {

		IOException processException = null;
		FileInputStream input = null;
		try {
			input = new FileInputStream(new File(path));
			process(input);
		} catch (IOException e) {
			processException = e;
		} finally {
			try {
				if (null != input) {
					input.close();
				}
			} catch (IOException e) {
				if (null == processException) {
					throw new ApplicationException(e);
				} else {
					throw new ApplicationException(
							"FileInputStream close exception", processException);
				}
			}
			if (processException != null) {
				throw new ApplicationException(processException);
			}
		}

	}

	public abstract void process(FileInputStream input) throws IOException;

}


使用方式: Client.java

public abstract class Client {

	public static void main(String[] args) throws ApplicationException {
		new FileInputStreamTemplate() {
			@Override
			public void process(FileInputStream input) throws IOException {
				byte[] buff = new byte[1024];
				while (-1 != input.read(buff)) {
					System.out.println(new String(buff));
				}
			}
		}.readFile("D:/test/itart.txt");
	}
}

这样代码是不是清晰很多, 为了让代码更加容易阅读, 我们可以进一步改进, 将模板方法改为静态模板方法, 定义一个process方法的接口, 具体如下

定义一个处理器接口InputStreamProcessor.java

public interface InputStreamProcessor {
	public void process(FileInputStream input) throws IOException;
}

模板方法改为静态模板方法 

public class FileInputStreamTemplate {
	public static void readFile(String path, InputStreamProcessor processor) throws ApplicationException {

		IOException processException = null;
		FileInputStream input = null;
		try {
			input = new FileInputStream(new File(path));
			processor.process(input);
		} catch (IOException e) {
			processException = e;
		} finally {
			try {
				if (null != input) {
					input.close();
				}
			} catch (IOException e) {
				if (null == processException) {
					throw new ApplicationException(e);
				} else {
					throw new ApplicationException(
							"FileInputStream close exception", processException);
				}
			}
			if (processException != null) {
				throw new ApplicationException(processException);
			}
		}
	}

}

调用方式: Client.java 

public abstract class Client {

	public static void main(String[] args) throws ApplicationException {
		FileInputStreamTemplate.readFile("D:/test/itart.txt", new InputStreamProcessor() {
			@Override
			public void process(FileInputStream input) throws IOException {
				byte[] buff = new byte[1024];
				while (-1 != input.read(buff)) {
					System.out.println(new String(buff));
				}
			}
		});
	}
}

InputStreamProcessor的实现类是采用匿名实现方式, 这是因为一般情况下这个类是不会被重复使用, 没有必要再定义一个子类.


模板方法可以有效的减少重复代码, 提高代码的可阅读性, 可维护性, 实际项目开发中, 可以应用模板方法的地方很多, 就像IO操作的地方, 如: 读写文件, 还有JDBC,  事务管理等等.


来源: IT艺术博客(http://www.itart.cn)



想搞艺术的程序员
关注
专栏目录
异常处理（try，catch，finally）
qq_46381044的博客
08-08 825
Java的异常处理是通过5个关键字来实现的：try、catch、 finally、throw、throws。
使用try-catch-finally处理异常
weixin_42388833的博客
11-22 2389
用法一览 try{ //需要被检测的异常代码 } catch（Exception e）{ //异常处理，即处理异常代码 } finally{ //一定会被执行的代码 } 可以在catch部分加上一句打印异常 System.out.println(e.ToString()); try+catch+finally Java通过面向对象的方法来处理异常。 在一个方法的运行过程中，如果发生了异常，则这个方法生成代表该异常的一个对象，并把它交给运行时系统，运行时系统寻找相应代码来处理这一
try-call:功能性try-catch，可实现更清晰的代码和优化
05-05
试用电话 功能性try-catch，用于更简洁的代码和。 安装 $ npm install try-call 用法 var call = require ( 'try-call' ) ; var doc = '{ "foo": 123 }' ; var parse = JSON . parse . bind ( null , doc ) ; call ( parse , function ( error , doc ) { error // => undefined doc // => { foo: 123} } )
try cathc finally 代码优化
04-26 549
boolean sucess=false;//业务处理成功标志 try{ ..... sucess=true； ...... ...} catch.... finally{    if(secess)iGoodCenterPushService.publishCMSandGPCQNMQ(iGoodCenterPushBeans); } OffPublishGoodsTa
系统性能调优(6)----Java异常处理性能优化
weixin_30713953的博客
06-12 406
执行一个catch代码块和抛出一个异常花费是很高的，这个过程中的性能损耗主要是由于当创建一个异常时要获得线程栈的一个快照。抛出异常首先要创建一个新的对象Throwable类的构造函数调用名为fillInStackTrace的方法，fillInStackTrace方法检查堆栈，收集调用跟踪信息。由于在处理过程中创建了一个新的对象，所以说只要有异常被抛出，JVM就必须调整调用堆栈，系统资源开...
try-catch-finally处理异常
Java技术
06-25 713
捕获：Java中对异常有针对性的语句进行指定方式的处理捕获异常格式 ： try { // 需要被检测的语句 } catch (异常类 变量) {// 参数 // TODO: handle exception // 处理的异常语句 } finally { // 一定会被执行的语句 } try:该代码块中编写可能产生异常的代码 catch:用来进行某种异常的捕...
java基础教程----精华版
09-22
- Java使用try-catch-finally结构处理异常，提供了一种统一的错误处理机制。 - 异常类层次结构，根类为`java.lang.Throwable`，常见的有`Exception`和`Error`。 4. **包（Package）**： - 为了管理类和接口，...
异常处理（try.catch.finally 与 throw.throws ）
再来一块红烧肉
03-22 509
我们为什么需要异常处理？ try.catch.finally 注意点 常用方法 throw.throws throw throws
异常捕获-master.zip项目安卓应用源码下载
03-09
try块包含可能会抛出异常的代码，catch块用于处理特定类型的异常，finally块则确保无论是否发生异常，某些代码总会执行，比如关闭文件流或网络连接。 在"异常捕获-master"项目中，我们可以学习如何使用全局异常...
Programming in objective - C.pdf
最新发布
06-28
5. **异常处理**：Objective-C使用`@try`、`@catch`、`@finally`块进行异常处理。 #### 四、Objective-C的高级特性 1. **协议**：协议定义了一组方法签名，指定一个类应该实现哪些方法。 2. **类别**：类别是对现有...
C++教程渥瑞达objective-c视频教程内含有 du盘链接
06-06
异常处理的关键字包括`@try`、`@catch`、`@finally`等。例如： ```objective-c @try { // 可能引发异常的代码 } @catch (NSException *exception) { NSLog(@"Caught an exception: %@", exception); } @finally { ...
try、catch优化你的程序
A_D_I_D_A_S的博客
01-28 633
今天依旧是刷题的一天，在做LeetCode的题目8时遇到了一个问题 Exception in thread “main” java.lang.NumberFormatException: For input string: “20000000000000000000” at java.lang.NumberFormatException.forInputString(NumberFormatEx...
Try catch使用模板
weixin_34290000的博客
04-12 383
2019独角兽企业重金招聘Python工程师标准>>> ...
Java异常机制及异常处理建议
Hopefully Sky的博客
08-26 4350
1、Java异常机制       异常指不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。Java通过API中Throwable类的众多子类描述各种不同的异常。因而，Java异常都是对象，是Throwable子类的实例，描述了出现在一段编码中的错误条件。当条件生成时，错误将引发异常。        Java异常类层次结构图：
模版方法模式 模仿Spring封装Hibernate 的try catch
libinxuan520的专栏
11-15 109
Template Method Pattern（模版方法模式）定义：定义一个操作中方法的骨架，以将一些步骤延缓到子类中实现，模版方法让子类重新定义一个方法的某些步骤而无须改变方法的结构。 其中类与对象的关系为：      AbstractClass：抽象类           定义一个抽象原始的操作，其子类可以重定义他的实现     ConcreteClass：具体子类    ...
如何优化Java异常的效率？
程序员小潘
08-06 484
1. 前言 在Java语言中，正如Object是所有对象的父类一样，Throwable是所有异常的父类。为什么会有异常类呢？程序是人开发出来的，而人难免是会犯错误的，因此程序可能会运行异常。一旦发生了异常，开发者首先要做的就是定位异常，然后解决异常。 如何解决异常那是开发者要做的事情，如何让开发者快速定位到异常，却是Java语言本身的职责。 ​ 因此，异常的基类Throwable有一个非常重要的属性【stackTrace】，它代表出现异常时，当前线程运行的堆栈信息。通过它，可以快速定位到该异常是在哪个类的哪
Java编程中异常处理 try-catch-finally语句的一些分析
冰霜青羽的博客
11-19 387
本文是一篇Java编程异常处理相关的学习笔记，包含了一些对 try-catch-finally的粗浅分析。
Java获取时间范围: 当前季度,上个季度,昨天,当前月,上个月
热门推荐
piaohai的专栏
09-06 2万+
Java中获取当前季度的时间范围, 上个季度的时间范围, 昨天的时间范围, 当前月的时间范围, 上个月的时间范围:   DateUtils.java   package top.itart.blog.common.util; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.D
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值