首先进入eclipse的maven配置界面Window》Preferences>Maven>User Settings

我新装的eclipse自带的Maven默认这个文件是不存在的，没关系,大家单击Browse新建文本文档,把文件名取为setting.xml然后把我下面的内容复制进去即可。

/home/yizhen/.m2/repositoryalimavenaliyun mavenhttp://maven.aliyun/nexus/content/groups/public/centralnexusnexuslocal private nexushttp://maven.oschina/content/groups/public/truefalsenexuslocal private nexushttp://maven.oschina/content/groups/public/truefalse

然后保存,Update setting更新一下,接下来设置本地仓库,如果你没有现成的仓库就不需要设置了。

有固定maven本地仓库的同学将respsitory放在在C盘的USER的用户名下的m.2目录下即可,然后Reindex重新建立索引,Apply and Close 应用然后关闭即可！

大家学会了吗,以后再也不用担心maven下载类库时蜗牛一样的速度了,以后大家下载速度都要和图上的木星自身转速一样快,哇哇的！！

一 注解的定义

注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明 。如果要对于元数据的作用进行分类，还没有明确的定义，不过我们可以根据它所起的作用，注解不会改变编译器的编译方式，也不会改变虚拟机指令执行的顺序，它更可以理解为是一种特殊的注释，本身不会起到任何作用，需要工具方法或者编译器本身读取注解的内容继而控制进行某种操作。大致可分为三类：

编写文档：通过代码里标识的元数据生成文档。

代码分析：通过代码里标识的元数据对代码进行分析。

编译检查：通过代码里标识的元数据让编译器能实现基本的编译检查。

二 用途

因为注解可以再代码编译期间帮我们完成一些复杂的准备工作，所以我们可以利用注解去完成我们的一些准备工作。比如Greendao，我们注解一个实体类，它要处理成好多逻辑关系类，这些逻辑类让我们自己去书写的话那将是一个庞大的代码量， extends AbstractDao等这些类。比如BufferKnife，我们用注解将控件的属性传递给它，它将生成一些功能类去处理这些值，***_ViewBinding等这些类型的类。运行时注解的使用,比如Retrofit的@GET或者@POST等等都是运行时注解，它的注解的处理必须跟Retrofit的对象有关联，所以必须定义成运行时的。所以注解已经成为一种趋势，比如BufferKnife，EventBus，Darrger，Greendao，Arouter，Retrofit。。。看来我们也要去完成我们的一个注解了。

三 知识准备

Java JDK中包含了三个注解分别为@Override（校验格式），@Deprecated：（标记过时的方法或者类），@SuppressWarnnings（注解主要用于抑制编译器警告）等等java1.8之后有新增了一些注解像@FunctionalInterface()这样的,对于每个注解的具体使用细节这里不再论述。我们可以通过点击这里来看一下专业解释! 来看一下@Override的源码。

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.SOURCE)

}

通过源代码的阅读我们可以看出生命注解的方式为@interface，每个注解都需要不少于一个的元注解的修饰，这里的元注解其实就是修饰注解的注解，可以理解成最小的注解单位吧。。。下面详细的看下每个注释注解的意义吧：

@Target：

说明了Annotation所修饰的对象范围,也就是我们这个注解是用在那个对象上面的：Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。以下属性是多选状态，我们可以定义多个注解作用域，比如：

@Target({ElementType.METHOD,ElementType.FIELD})，单个的使用 @Target(ElementType.FIELD)。

（1）.CONSTRUCTOR：构造方法声明。

（2）.FIELD：用于描述域也就是类属性之类的，字段声明（包括枚举常量）。

（3）.LOCAL_VARIABLE：用于描述局部变量。

（4）.METHOD：用于描述方法。

（5）.PACKAGE：包声明。

（6）.PARAMETER：参数声明。

（7）.TYPE：类、接口（包括注释类型）或枚举声明 。

(8) .ANNOTATION_TYPE：注释类型声明，只能用于注释注解。

官方解释：指示注释类型所适用的程序元素的种类。如果注释类型声明中不存在 Target 元注释，则声明的类型可以用在任一程序元素上。如果存在这样的元注释，则编译器强制实施指定的使用限制。 例如，此元注释指示该声明类型是其自身，即元注释类型。它只能用在注释类型声明上:

@Target(ElementType.ANNOTATION_TYPE)

public @interface MetaAnnotationType {

}

此元注释指示该声明类型只可作为复杂注释类型声明中的成员类型使用。它不能直接用于注释：

@Target({})

public @interface MemberType {

...

}

这是一个编译时错误，它表明一个 ElementType 常量在 Target 注释中出现了不只一次。例如，以下元注释是非法的：

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.FIELD})

public @interface Bogus {

...

}

@Retention：

定义了该Annotation被保留的时间长短：某些Annotation仅出现在源代码中，而被编译器丢弃；而另一些却被编译在class文件中；编译在class文件中的Annotation可能会被虚拟机忽略，而另一些在class被装载时将被读取（请注意并不影响class的执行，因为Annotation与class在使用上是被分离的）。使用这个meta-Annotation可以对 Annotation的“生命周期”限制。来源于java.lang.annotation.RetentionPolicy的枚举类型值：

（1）.SOURCE:在源文件中有效（即源文件保留）编译成class文件将舍弃该注解。

（2）.CLASS:在class文件中有效（即class保留） 编译成dex文件将舍弃该注解。

（3）.RUNTIME:在运行时有效（即运行时保留） 运行时可见。

也就是说注解处理器能处理这三类的注解,我们通过反射的话只能处理RUNTIME类型的注解.

官方解释：指示注释类型的注释要保留多久。如果注释类型声明中不存在 Retention 注释，则保留策略默认为 RetentionPolicy.CLASS。只有元注释类型直接用于注释时，Target 元注释才有效。如果元注释类型用作另一种注释类型的成员，则无效。

@Documented：

指示某一类型的注释将通过 javadoc 和类似的默认工具进行文档化。应使用此类型来注释这些类型的声明：其注释会影响由其客户端注释的元素的使用。如果类型声明是用 Documented 来注释的，则其注释将成为注释元素的公共 API 的一部。Documented是一个标记注解，没有成员。

@Inherited：

元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。 注意：@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继承性。如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，直到发现指定的annotation类型被发现，或者到达类继承结构的顶层。

官方解释：指示注释类型被自动继承。如果在注释类型声明中存在 Inherited 元注释，并且用户在某一类声明中查询该注释类型，同时该类声明中没有此类型的注释，则将在该类的超类中自动查询该注释类型。此过程会重复进行，直到找到此类型的注释或到达了该类层次结构的顶层 (Object) 为止。如果没有超类具有该类型的注释，则查询将指示当前类没有这样的注释。

注意，如果使用注释类型注释类以外的任何事物，此元注释类型都是无效的。还要注意，此元注释仅促成从超类继承注释；对已实现接口的注释无效。

@Repeatable：

Repeatable可重复性，Java 1.8新特性，其实就是把标注的注解放到该元注解所属的注解容器里面。可重复性的意思还是用demo来解释一下吧：

//定义了一个 注解里面属性的返回值是其他注解的数组

@Target(ElementType.FIELD)

@Retention(RetentionPolicy.RUNTIME)

public @interface MyCar {

MyTag[] value(); ----MyTag 这里就是MyTag注解的容器。

}

//另外一个注解 就是上一个注解返回的注解

@Target({ElementType.METHOD,ElementType.FIELD})

@Retention(RetentionPolicy.CLASS)

@Repeatable(MyCar.class) --------这里添加这个属性之后 我们的这个注解就可以重复的添加到我们定义的容器中了，注意里面的值时 我们定义的容器注解的class对象.

public @interface MyTag { ........MyTag

String name () default "" ;

int size () default 0 ;

}

//使用

@MyTag(name = "BWM", size = 100)

@MyTag()

public Car car;

//如果我们的注解没有@Repeatable的话,这样写的话是报错的,加上之后就是这样的了

这个注解是很特殊的，我们的注解中有@Repeatable(MyCar.class)这样的元注解的话，就是说当前标注的注解（MyTag注解）放到我们的值（MyCar.class）这个注解容器里面。那么我们再处理注解的时候获取到的是我们最后的注解容器（MyCar注解）,这样说有点生硬下面看demo：

使用:

public class HomeActivity extends AppCompatActivity {

@MyTag(name = "BWM", size = 100)

@MyTag(name = "大众" ,size = 200) ......这里用了它的重复性.

Car car;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_home);

AnnotationProccessor.instance().inject(this); //这里去处理注解

// Log.e("WANG", "HomeActivity.onCreate." + car.toString());

}

}

处理过程:

Class aClass = o.getClass();

Field[] declaredFields = aClass.getDeclaredFields();

for (Field field:declaredFields) {

if(field.getName().equals("car")){

Annotation[] annotations = field.getAnnotations();

for (int i = 0; i

Annotation annotation = annotations[i];

//我们获取的该字段上面的注解只有一个 那就是 MyCar注解,看结果1的打印.

//但是我们明明标注的是 MyTag. 为什么获取的是注解容器呢.

//这就是@Repeatable的强大之处.

Class aClass1 = annotation.annotationType();

Log.e("WANG","AnnotationProccessor.MyCar"+aClass1 );

}

MyCar annotation = field.getAnnotation(MyCar.class);

MyTag[] value = annotation.value();

for (int i = 0; i

MyTag myTag = value[i];

Log.e("WANG","AnnotationProccessor.MyTag name value is "+myTag.name() );

}

}

结果是:

AnnotationProccessor.MyCarinterface cn.example.wang.routerdemo.annotation.MyCar.1

AnnotationProccessor.MyTag name value is BWM.2

AnnotationProccessor.MyTag name value is 大众.3

三 自定义运行时注解

通过以上的学习我们知道@interface是声明注解的关键字,每个注解需要注明生命周期以及作用范围.你可以给注解定义值.也就是再注解内部定义我们需要的方法.这样注解就可以再自己的生命周期内为我们做事.这里我们就自定义一个为一个对象属性初始化的注解吧，类似于Dagger的功能。

public @interface MyTag {

}

注解里面的定义也是有规定的：

注解方法不能带有参数。注解方法返回值类型限定为：基本类型、String、Enums、Annotation或者这些类型的数组。注解方法可以有默认值。注解本身能够包含元注解，元注解被用来注解其他注解。

我们就来试一下吧！

public @interface MyTag {

//声明返回值类型，这里可没有大括号啊，可以设置默认返回值，然后就直接";"了啊。

String name () default "" ;

int size () default 0 ；

}

定义好了注解我们就来规定我们自定义的注解要在哪里用？要何时用？因为我们这里使用了反射来处理注解，反射就是在代码的运行的时候通过class对象反相的去获取类内部的东西，不熟悉反射机制的请移步这里Android开发者必须了解的反射基础，所以我们定义该注解的生命周期在运行时，并且该注解的的目的是为自定义属性赋值，那么我们的作用域就是FIELD。这里面定义了我们要初始化的bean的基本属性，给了默认值。这样我们就可以用该注解去创建我们需要的bean对象。

@Target(ElementType.FIELD)

@Inherited

@Retention(RetentionPolicy.RUNTIME)

public @interface MyTag {

String name () default "" ;

int size () default 0 ;

}

好了接下来看怎么使用我们的这个自定义的注解！

public class HomeActivity extends AppCompatActivity {

@MyTag(name = "BMW",size = 100)

Car car;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_home);

//这里我们要首先注册一下这个类

AnnotationCar.instance().inject(this);

//当程序运行的时候这里将会输出该类Car的属性值。

Log.e("WANG","Car is "+car.toString());

}

}

注解如果没有注解处理器，那么该注解将毫无意义。这里呢我们在这个Activity里面定义了一个Car类的属性，然后再car这个变量上面定义我们的注解，并且给我们的注解赋值。然后我们再onCreate方法里面初始化我们的注解处理器。然后运行代码，log日志将打印Car类的信息，先来看下结果吧

cn.example.wang.routerdemo E/WANG: Car is Car [name=BMW, size=100]

这样我们的自定义注解就有作用了，下面是”注解处理器“的代码，这里都是我们自己编写的处理注解的代码，其实系统是自带注解处理器的，不过它一般用来处理源码注释和编译时注释。

//自定义的类

/**

* Created by WANG on 17/11/21.

*/

public class AnnotationCar {

private static AnnotationCar annotationCar;

public static AnnotationCar instance(){

synchronized (AnnotationCar.class){

if(annotationCar == null){

annotationCar = new AnnotationCar();

}

return annotationCar;

}

}

public void inject(Object o){

Class aClass = o.getClass();

Field[] declaredFields = aClass.get...

Java在处理数据量比较大的时候，加载到内存必然会导致内存溢出，而在一些数据处理中我们不得不去处理海量数据，那Java是如何处理大数据的呢？有什么技巧吗？在做数据处理中，我们常见的手段是分解，压缩，并行，临时文件等方法。

例如，我们要将数据库（不论是什么数据库）的数据导出到一个文件，一般是Excel或文本格式的CSV；对于Excel来讲，对于POI和JXL的接口，你很多时候没有办法去控制内存什么时候向磁盘写入，很恶心，而且这些API在内存构造的对象大小将比数据原有的大小要大很多倍数，所以你不得不去拆分Excel，还好，POI开始意识到这个问题，在3.8.4的版本后，开始提供cache的行数，提供了SXSSFWorkbook的接口，可以设置在内存中的行数，不过可惜的是，他当你超过这个行数，每添加一行，它就将相对行数前面的一行写入磁盘（如你设置2000行的话，当你写第20001行的时候，他会将第一行写入磁盘），其实这个时候他的临时文件，以至于不消耗内存，不过这样你会发现，刷磁盘的频率会非常高，我们的确不想这样，因为我们想让他达到一个范围一次性将数据刷入磁盘，比如一次刷1M之类的做法，可惜现在还没有这种API，很痛苦，我自己做过测试，通过写小的Excel比使用目前提供刷磁盘的API来写大文件，效率要高一些，而且这样如果访问的人稍微多一些磁盘IO可能会扛不住，因为IO资源是非常有限的，所以还是拆文件才是上策；而当我们写CSV，也就是文本类型的文件，我们很多时候是可以自己控制的，不过你不要用CSV自己提供的API，也是不太可控的，CSV本身就是文本文件，你按照文本格式写入即可被CSV识别出来；如何写入呢？下面来说说。。。

在处理数据层面，如从数据库中读取数据，生成本地文件，写代码为了方便，我们未必要1M怎么来处理，这个交给底层的驱动程序去拆分，对于我们的程序来讲我们认为它是连续写即可；我们比如想将一个1000W数据的数据库表，导出到文件；此时，你要么进行分页，Oracle当然用三层包装即可，MySQL用limit，不过分页每次都会新的查询，而且随着翻页，会越来越慢，其实我们想拿到一个句柄，然后向下游动，编译一部分数据（如10000行）将写文件一次（写文件细节不多说了，这个是最基本的），需要注意的时候每次buffer的数据，在用outputstream写入的时候，最好flush一下，将缓冲区清空下。

来设置游标的方式，以至于游标不是将数据直接cache到本地内存，然后通过设置statement.setFetchSize(200);设置游标每次遍历的大小；OK，这个其实我用过，oracle用了和没用没区别，因为oracle的jdbc API默认就是不会将数据cache到java的内存中的，而mysql里头设置根本无效，我上面说了一堆废话，呵呵，我只是想说，java提供的标准API也未必有效，很多时候要看厂商的实现机制，还有这个设置是很多网上说有效的，但是这纯属抄袭；对于oracle上面说了不用关心，他本身就不是cache到内存，所以java内存不会导致什么问题，如果是mysql，首先必须使用5以上的版本，然后在连接参数上加上useCursorFetch=true这个参数，至于游标大小可以通过连接参数上加上：defaultFetchSize=1000来设置，

上次被这个问题纠结了很久（mysql的数据老导致程序内存膨胀，并行2个直接系统就宕了），还去看了很多源码才发现奇迹竟然在这里，最后经过mysql文档的确认，然后进行测试，并行多个，而且数据量都是500W以上的，都不会导致内存膨胀，GC一切正常，这个问题终于完结了。

Java在处理大数据的时候还是有一些小技巧的，正确运用这些小技巧，有时候在处理问题时往往会事半功倍。

声明：本栏目所使用的素材都是凯哥学堂VIP学员所写，学员有权匿名，对文章有最终解释权；凯哥学堂旨在促进VIP学员互相学习的基础上公开笔记。

Java导出Excel表

首先去maven里面下载 upload 1.3.3 版本 下载到你的maven工程里面

上传文件必须是post方法

上传文件同时有表单值的话 你用request.getParame是获得不到的

Java导出Excel表

去maven工厂下载 POI jar包

对JDBC的封装?

1．将变的内容以参数形式传入

2．将不变的固定下来

Java处理EXCEL？【JXL】

1．读

2．写

WEB基础知识

第一、两种架构

1．C/S:Client /Server 客户端 服务器 模式

QQ 360 大型网络游戏

2．B/S:Browser/Server 浏览器 服务器 模式

网站 应用系统 页游

第二、网络中的计算机，进行通信，所遵循的规范，称之为协议。

第三、在JAVAWEB中，客户端和服务器进行交互遵循的是HTTP协议。

第四、HTTP是一种建立在TCP协议基础之上，基于请求、响应模式的无状态的应用层协议。

第五、请求：从客户端发往服务器的信息【字符串】。

1．请求行 请求的方法 资源 协议版本HTTP/1.1

2．请求头 Host Accept Accept-language....

3．空格

4．消息体 key1=value1&key2=value2

第六、响应: 从服务器返回到客户端信息【字符串】

1．状态行 协议版本 状态码 状态字符串

2．响应头 Content-Type Conent-length cookie: .....

3．空格

4．响应正文

第七、浏览器:能够发出标准的HTTP请求，并可以解析标准的HTTP响应的软件（一堆别人写的代码（不一定使用JAVA））

第八、WEB服务器：是一种能够接受标准的HTTP请求，返回标准的HTTP响应的软件。

第九、Tomcat就是一款免费的开源的纯JAVA实现的WEB服务器。

第十、Servlet/JSP容器：提供了Servlet运行环境，管理Servlet的生命周期的一个组件（一堆类，零件）。一般容器存在于服务器中。比如:Tomcat中就有一个servlet容器catalina

第十一、Servlet=JAV代码+HTML标签（以JAVA代码为主） JSP=HTML标签+JAVA代码（以标签为主）

一.POI简单介绍

Apache POI 是用Java 编写的免费开源的跨平台的 Java API，Apache POI提供API给Java程式对 Microsoft Office 格式档案读和写的功能

HSSF 提供读写Microsoft Excel XLS格式档案的功能。

XSSF 提供读写Microsoft Excel OOXML XLSX格式档案的功能。

HWPF 提供读写Microsoft Word DOC格式档案的功能。

HSLF 提供读写Microsoft PowerPoint格式档案的功能。

HDGF 提供读Microsoft Visio格式档案的功能。

HPBF 提供读Microsoft Publisher格式档案的功能。

HSMF 提供读Microsoft Outlook格式档案的功能。

二.操作步骤

1.环境配置：导入jar包

org.apache.poi poi 3.16

2.创建一个Excel工作簿

@Test public void test() throws IOException { //定义一个工作蒲 Workbook wb = new HSSFWorkbook(); //定义一个输出流 FileOutputStream fileOutputStream = new FileOutputStream("/home/ubuntu/Desktop/Excel工作蒲.xls"); //写入在输出流 wb.write(fileOutputStream); //关闭输出流 fileOutputStream.close(); }

3.创建一个sheet页

@Test public void sheet() throws IOException { //定义一个工作蒲 Workbook wb = new HSSFWorkbook(); //创建sheet页面 wb.createSheet("第一个sheet页"); wb.createSheet("第二个sheet页"); //定义一个输出流 FileOutputStream fileOutputStream = new FileOutputStream("/home/ubuntu/Desktop/Excel工作蒲带有sheet页.xls"); //写入在输出流 wb.write(fileOutputStream); //关闭输出流 fileOutputStream.close(); }

sheet页

4.创建行和列

@Test public void row() throws IOException { //定义一个工作蒲 Workbook wb = new HSSFWorkbook(); //创建sheet页面 Sheet sheet = wb.createSheet("学生信息sheet页"); //创建一行 Row row = sheet.createRow(0); //创建一个单元格 Cell cell =null; for(int i = 0 ;i<5;i++){ row.createCell(i).setCellValue("写入信息：单元格内容"+i); } //定义一个输出流 FileOutputStream fileOutputStream = new FileOutputStream("/home/ubuntu/Desktop/Excel学生信息.xls"); //写入在输出流 wb.write(fileOutputStream); //关闭输出流 fileOutputStream.close(); }

5.创建一个时间样式到Excel

@Test public void date() throws IOException { //定义一个工作蒲 Workbook wb = new HSSFWorkbook(); //创建sheet页面 Sheet sheet = wb.createSheet("时间sheet页"); //创建一行 Row row = sheet.createRow(0); //创建一个单元格 Cell cell = row.createCell(0); cell.setCellValue(new Date()); CreationHelper creationHelper = wb.getCreationHelper(); //设置单元格样式 CellStyle cellStyle = wb.createCellStyle(); cellStyle.setDataFormat(creationHelper.createDataFormat().getFormat("YYYY-MM-DD hh:mm:ss")); cell = row.createCell(1); cell.setCellValue(new Date()); //设置日期样式 cell.setCellStyle(cellStyle); //定义一个输出流 FileOutputStream fileOutputStream = new FileOutputStream("/home/ubuntu/Desktop/Excel日期格式.xls"); //写入在输出流 wb.write(fileOutputStream); //关闭输出流 fileOutputStream.close(); }

6.单元格对其方式及行高

@Test public void style() throws IOException { //定义一个工作蒲 Workbook wb = new HSSFWorkbook(); //创建sheet页面 Sheet sheet = wb.createSheet("第一个sheet"); //创建一行 Row row = sheet.createRow(0); //设置行高 row.setHeightInPoints(30); //创建一个单元格 createCell(wb,row,(short)0,HSSFCellStyle.ALIGN_CENTER,HSSFCellStyle.VERTICAL_BOTTOM); createCell(wb,row,(short)1,HSSFCellStyle.ALIGN_JUSTIFY,HSSFCellStyle.VERTICAL_CENTER); createCell(wb,row,(short)2,HSSFCellStyle.ALIGN_CENTER_SELECTION,HSSFCellStyle.VERTICAL_JUSTIFY); //定义一个输出流 FileOutputStream fileOutputStream = new FileOutputStream("/home/ubuntu/Desktop/Excel样式.xls"); //写入在输出流 wb.write(fileOutputStream); //关闭输出流 fileOutputStream.close(); } /** * 创建一个单元格设置对应的对其方式 * @param workbook 工作蒲 * @param row 行 * @param column 列 */ private static void createCell(Workbook workbook, Row row, short column,short halign,short valign){ Cell cell = row.createCell(column);//创建单元格 cell.setCellValue(new HSSFRichTextString("我是富文本"));//设置值 CellStyle cellStyle = workbook.createCellStyle();//创建样式 cellStyle.setAlignment(halign);//设置单元格水平方向对其方式 cellStyle.setVerticalAlignment(valign);//设置单元格垂直方向对其方式 cell.setCellStyle(cellStyle); }

合并单元格

@Test public void test1() throws IOException { //定义一个工作蒲 Workbook wb = new HSSFWorkbook(); //创建sheet页面 Sheet sheet = wb.createSheet("第一个sheet"); //创建一行 Row row = sheet.createRow(1); //设置行高 row.setHeightInPoints(30); //创建一个单元格 Cell cell = row.createCell(1); cell.setCellValue("合并单元格"); //合并单元格（起始行,结束行,起始列,结束列） sheet.addMergedRegion(new CellRangeAddress(1,2,1,2)); //定义一个输出流 FileOutputStream fileOutputStream = new FileOutputStream("/home/ubuntu/Desktop/Excel样式.xls"); //写入在输出流 wb.write(fileOutputStream); //关闭输出流 fileOutputStream.close(); }

PHPExcel是一个PHP类库，用来帮助我们简单、高效实现从Excel读取Excel的数据和导出数据到Excel。也是我们日常开发中，经常会遇到的使用场景。PHPExcel可以快速导入客户信息，避免人工录入信息的麻烦。这里分享下读取数据的过程

1. 下载PHPexcel, 我这里下载的PHPExcel-1.8

2. 将下载的文件解压缩拷贝到项目目录中,如图：

3. 准备好要读取的excel文件，如图：

4. 加载PHPexcel文件并读取数据：

5. 读取结果如下：

Java程序员读取和计算excel的程序一般要使用poi或其它开源包，这些开源包对编程的支持较为底层，整体学习成本和操作复杂度都很高。使用集算器辅助java处理excel文件就可以避免这些事务。

下面通过一个例子看一下具体作法：从Excel文件orders.xls中读取订单信息，找出2010年1月1日（含）之后，SELLERID等于18的订单。orders.xls的内容如下：

实现的思路是：用Java程序调用集算器脚本，读取和计算excel文件中的数据，之后将结果以ResultSet的方式返回给Java程序。由于集算器支持动态表达式解析和求值，使得Java程序可以像使用sql那样，灵活的处理数据。

首先，程序员可以将条件“2010年1月1日（含）之后，并且SELLERID等于18的订单。”作为参数where传递给esProc程序，如下图：

where是个字串，其值为：ORDERDATE>=date(2010,1,1) && SELLERID==18。

esProc的程序代码如下：

A2：按照条件过滤。这里使用宏来实现动态解析表达式，其中的where就是传入参数。集算器将先计算${…}里的表达式，将计算结果作为宏字符串值替换${…}之后解释执行。这个例子中最终执行的是：=A1.select(ORDERDATE>=date(2010,1,1) && SELLERID==18)。A1：定义一个file对象，导入excel数据。esProc的集成开发环境可以直观的显示出导入的数据，如上图右边部分。importxls函数也可以读写xlsx文件，它会根据文件扩展名自动判断excel的版本。

A3：将符合条件的结果集返回给java。如果需要将结果写入另外一个excel文件，只要将A3单元格改为：=file("D:/file/orders_result.xls").exportxls@t(A2)。

过滤条件发生变化时不用改变程序，只需改变where参数即可。例如，条件变为：2010年1月1日（含）之后，并且SELLERID等于18的订单，或者CLIENT等于PWQ的订单。Where的参数值可以写为：CLIENT=="PWQ"||ORDERDATE>=date(2010,1,1) && SELLERID==18。执行之后，A2中的结果集如下图：

在Java程序中使用esProc JDBC调用这段程序获得结果的代码如下：（将上述esProc程序保存为test.dfx）：

//建立esProc jdbc连接

Class.forName("com.esproc.jdbc.InternalDriver");

con= DriverManager.getConnection("jdbc:esproc:local://");

//调用esProc程序（存储过程），其中test是dfx的文件名

com.esproc.jdbc.InternalCStatementst =(com.esproc.jdbc.InternalCStatement)con.prepareCall("call test(?)");

//设置参数

st.setObject(1,"ORDERDATE>=date(2010,1,1) && SELLERID==18 || CLIENT==\"PWQ\"");//执行esProc存储过程

ResultSet set =st.executeQuery();

对于代码较简单的脚本，还可以把代码直接写在调用集算器JDBC的Java程序中，而不必专门编写脚本文件（test.dfx）：

ResultSet set = st.executeQuery(

"=file(\"D:/file/orders.xls\").importxls@t().select(ORDERDATE>=date(2010,1,1) && SELLERID==18 || CLIENT==\"PWQ\")");

这段Java代码直接调用了集算器的一句脚本：从Excel文件中取得数据，并按照指定的条件过滤。

前段时间在 github 上发现了阿里的 EasyExcel 项目，觉得挺不错的，就写了一个简单的方法封装，做到只用一个函数就完成 Excel 的导入或者导。刚好前段时间更新修复了一些 BUG，就把我的这个封装分享出来，请多多指教。

附上源码：

https://github/HowieYuan/easyexcel-method-encapsulation

EasyExcel

EasyExcel 的 github 地址：

https://github/alibaba/easyexcel

EasyExcel 的官方介绍：

可以看到 EasyExcel 最大的特点就是使用内存少，当然现在它的功能还比较简单，能够面对的复杂场景比较少，不过基本的读写完全可以满足。

一. 依赖

首先是添加该项目的依赖，目前的版本是 1.0.2。

com.alibabaeasyexcel1.0.2

二. 需要的类

1. ExcelUtil

工具类，可以直接调用该工具类的方法完成 Excel 的读或者写。

2. ExcelListener

监听类，可以根据需要与自己的情况，自定义处理获取到的数据，我这里只是简单地把数据添加到一个 List 里面。

publicclassExcelListenerextendsAnalysisEventListener {//自定义用于暂时存储data。//可以通过实例获取该值private List