如何提高代码的质量

 废话在前：只有总结，才能进步。

 

近日有人问起，“你认为如何能提高代码的质量”，虽然都说出来了，但缺乏条理，特总结于此。

 

首先，应明确什么样的代码算是质量高的。然后才能知道如何去做。

 

我觉得，高质量的代码应该至少包括：

1.可读性。

2.可维护性。

 

代码的可读性同样有助于代码的可维护性。有时候在一个项目里，你修改的代码未必是自己写的，如果代码写的可读性很差，那将是非常痛苦的。

 

一、可读性

1.包名、类名、成员变量名、方法名、局部变量名等的命名应仔细斟酌。尽量做到读一段代码，就像是读一句话一样，在阅读的过程中就能理解其中的逻辑。

2.包下面应包含哪些类，这也是有讲究的。不能太随意。从包中应该可以大概看出类的功能或所在层次。

3.一个方法只要实现一个功能。这一点很重要，首先利于阅读，方法的名字可以告诉你它的功能。

4.方法的实现不宜过长，个人写代码的习惯是，一个方法的长度不会超过电脑的一屏。也就是不用拖动滚动条便可把实现尽收眼底。

 

二、可维护性

1.代码写的要灵活，尤其是一些配置文件。比如写一个下载程序，文件的放置路径就不能在代码中写死。因为一来以后要变动的话，还要来改程序，并重新部署；二来开发的环境与正式的环境有所不同，写死也不利于部署。

最典型的例子就是数据库的连接信息，url、用户名、密码等，开发环境与正式环境一般不会相同，把这些信息写在配置文件里为好。

2.提高的代码复用，以提高代码的维护性。

举个反例吧。我们的系统中有很多生成Excel文件并在浏览器端下载的功能要求，由于这些功能由不同的人来完成，结果类似的程序写了二十几份，都是互相拷贝而来。

当时我们用的是POI的低版本，后来进行了POI的升级，有一些API不能使用了，于是改了二十几个类。如果把这些功能复用一些，也许只要修改一个类文件就搞定了。

3.多用一些设计模式，提高代码的层次感。使得修改代码的时候，影响范围达到尽量的小。这个就有难度了。平时要慢慢积累才行。

常用的模式 工厂模式、模板模式、适配器模式、策略模式、代理模式(动态代理) 等。这些模式在平时的工作中经常用到，应该熟练运用才行。

 

下面是一些代码片段：

private void checkJob(JobConfig job) { JobConfig original = find(job); if (original != null) { // 已存在的任务 进行替换 if (original.equals(job)) { // 任务没有变更 } else if (replace(original, job)) { // 替换作业成功 则加入到新作业列表中 allJobs.remove(original); } } else if (schedule(job)) { // 新添加的任务 log.info(Log4jHelper.getLogMain(job) + "派发成功。"); } } private JobConfig find(JobConfig job) { for (JobConfig j : allJobs) { // 找到相同作业ID的任务 if (j.getJobId().equals(job.getJobId())) { return j; } } return null; } private boolean replace(JobConfig original, JobConfig job) { return remove(original) && schedule(job); } private boolean remove(JobConfig job) { try { return schedulerService.remove(job); } catch (SchedulerException e) { e.printStackTrace(); log.error(Log4jHelper.getLogMain(job) + "移除失败。"); } return false; } private boolean schedule(JobConfig job) { try { schedulerService.schedule(job); } catch (Exception e) { e.printStackTrace(); log.error(Log4jHelper.getLogMain(job) + "派发失败。"); return false; } return true; }

 

import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.net.MalformedURLException; import java.net.URL; import java.util.ArrayList; import java.util.List; import org.apache.commons.collections.Predicate; import org.springframework.core.io.ClassPathResource; import org.springframework.core.io.Resource; import org.springframework.core.io.support.PathMatchingResourcePatternResolver; import org.springframework.core.type.classreading.CachingMetadataReaderFactory; import org.springframework.core.type.classreading.MetadataReader; import org.springframework.core.type.classreading.MetadataReaderFactory; import com.lim.base.exception.AppException; /** * A collection of class management utility methods. * */ @SuppressWarnings("unchecked") public class ClassUtils { /** * 获得泛型类泛型参数类型. * 例如： * getGenericArgumentsType(List<String>.class)返回Class<String>. * @param <T> * @param cls * @return */ public static <T> Class<T> getGenericArgsType(Class<?> cls) { return getGenericArgumentsType(cls, 0); } /** * 获得泛型类泛型参数类型. * @param <T> * @param cls * @param pos * @return */ public static <T> Class<T> getGenericArgumentsType(Class<?> cls, int pos) { return (Class<T>) ((ParameterizedType) cls.getGenericSuperclass()).getActualTypeArguments()[pos]; } /** * 在指定的类路径查找符合条件的类.<br/> * @param classPathPattern * @param predicate * @return */ public static Class<?>[] getClasses(String classPathPattern, Predicate predicate) { PathMatchingResourcePatternResolver resolver = null; resolver = new PathMatchingResourcePatternResolver(); MetadataReaderFactory metaFactory = null; metaFactory = new CachingMetadataReaderFactory(resolver); try { Resource[] resources = resolver.getResources("classpath*:" + classPathPattern); ArrayList<Class<?>> clazzArr = new ArrayList<Class<?>>(); for (Resource res : resources) { if (!res.isReadable()) { continue; } MetadataReader metadataReader = metaFactory.getMetadataReader(res); String className = metadataReader.getClassMetadata().getClassName(); Class<?> clazz = ClassUtils.loadClass(className); if (predicate.evaluate(clazz)) { clazzArr.add(clazz); } } return clazzArr.toArray(new Class<?>[0]); } catch (IOException e) { throw new AppException(e); } catch (LinkageError e) { throw new AppException(e); } } /** * 在指定的类路径查找指定父类/接口类的所有子类. * Example: * Class<ITagChecker>[] checkerClz = ClassUtils.getSubClasses("com/linkage/ess/**<pre>/*</pre>.class", ITagChecker.class); * @param <T> * @param classPathPattern * @param superClass * @return */ public static <T> Class<? extends T>[] getSubClasses(String classPathPattern, final Class<T> superClass) { return (Class<? extends T>[]) getClasses(classPathPattern, new Predicate() { @Override public boolean evaluate(Object arg0) { Class<?> clazz = (Class<?>) arg0; return !clazz.isInterface() && superClass.isAssignableFrom(clazz); } }); } /** * Create a new instance given a class name(要求有默认构造函数). * * @param className * A class name * @return A new instance * @throws ClassNotFoundException * @throws IllegalAccessException * @throws InstantiationException * @exception Exception * If an instantiation error occurs */ public static <T> T newInstance(Class<T> clz) { try { return clz.newInstance(); } catch (InstantiationException e) { e.printStackTrace(); throw new AppException(e); } catch (IllegalAccessException e) { e.printStackTrace(); throw new AppException(e); } } /** * 带有参数的实例创建. * @param <T> * @param impl * @param param * @param params * @return */ public static <T> T newInstance(Class<T> impl, Object... params) { List<Class<?>> lstClass = new ArrayList<Class<?>>(params.length + 1); for (Object obj : params) { lstClass.add(obj.getClass()); } Class<?> paramClasses[] = lstClass.toArray(new Class<?>[0]); return newInstance(impl, paramClasses, params); } /** * 带有参数的实例创建. * @param <T> * @param impl * @param paramClasses * @param params * @return */ public static <T> T newInstance(Class<T> impl, Class<?> paramClasses[], Object params[]) { try { Constructor<T> constructor = impl.getConstructor(paramClasses); return constructor.newInstance(params); } catch (InstantiationException e) { e.printStackTrace(); throw new AppException(e); } catch (IllegalAccessException e) { e.printStackTrace(); throw new AppException(e); } catch (IllegalArgumentException e) { throw new AppException(e); } catch (InvocationTargetException e) { throw new AppException(e); } catch (SecurityException e) { throw new AppException(e); } catch (NoSuchMethodException e) { throw new AppException(e); } } /** * 使用类型的实例创建.(要求有默认构造函数). * @param className * @return */ public static Object newInstance(String className) { try { return loadClass(className).newInstance(); } catch (InstantiationException e) { e.printStackTrace(); throw new AppException(e); } catch (IllegalAccessException e) { e.printStackTrace(); throw new AppException(e); } } /** * Load a class given its name. BL: We wan't to use a known * ClassLoader--hopefully the heirarchy is set correctly. * * @param className * A class name * @return The class pointed to by <code>className</code> * @exception ClassNotFoundException * If a loading error occurs */ public static Class<?> loadClass(String className) { try { return getClassLoader().loadClass(className); } catch (ClassNotFoundException e) { throw new AppException(e); } } public static Method getMethod(String className, String name, Class<?>... parameterTypes) { return getMethod(loadClass(className), name, parameterTypes); } public static Method getMethod(Class<?> cls, String name, Class<?>... parameterTypes) { try { return cls.getMethod(name, parameterTypes); } catch (SecurityException e) { throw new AppException(e); } catch (NoSuchMethodException e) { throw new AppException(e); } } /** * Return a resource URL. BL: if this is command line operation, the * classloading issues are more sane. During servlet execution, we * explicitly set the ClassLoader. * * @return The context classloader. * @exception MalformedURLException * If a loading error occurs */ public static URL getResource(String resource) { return getClassLoader().getResource(resource); } public static InputStream loadResource(String path) { try { return new ClassPathResource(path).getInputStream(); } catch (IOException e) { e.printStackTrace(); throw new AppException(e); } } /** * Return the context classloader. BL: if this is command line operation, * the classloading issues are more sane. During servlet execution, we * explicitly set the ClassLoader. * * @return The context classloader. */ public static ClassLoader getClassLoader() { return Thread.currentThread().getContextClassLoader(); } public static Field getDeclaredField(Class<?> cls, String fieldName) { try { return cls.getDeclaredField(fieldName); } catch (Exception e) { throw new AppException(e); } } public static Object invokeQuietly(Object target, Method m) { try { return m.invoke(target); } catch (IllegalArgumentException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); if (e.getTargetException() instanceof RuntimeException) { throw (RuntimeException) e.getTargetException(); } } return null; } }