精华内容
下载资源
问答
  • 主要介绍了Java实现数据库导出大量数据记录并保存到文件的方法,涉及Java针对数据库的读取及文件写入等操作技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • java jdbc导出数据库大量数据

    千次阅读 2018-11-04 20:15:41
    java 导出数据库数据,在数据量比较大的情况下,如果全部将数据读到内存中再执行写文件,很容易遇到内存溢出;为了避免内存溢出的问题,可以尝试两种方式: 分页查询,每页写一次文件 使用游标的方式,边读边写 ...

    背景

    java 导出数据库数据,在数据量比较大的情况下,如果全部将数据读到内存中再执行写文件,很容易遇到内存溢出;为了避免内存溢出的问题,使用游标的方式,边读边写;

    分页的方式,当数据量较大的情况下,需要花费一些建立数据库连接的消耗,而且存在事务的问题,比如导出第二页数据的时候,在第一页插入了内容,那么第二页就会导出重复的数据,也不是很推荐,所以可以尝试使用游标的方式;

    数据准备

    BEGIN
    	FOR i IN 1..2000000
    	LOOP
    -- 	插入数据SQL
    	INSERT INTO ......
    -- 	
    IF
    	i MOD 10000 = 0 THEN
    	COMMIT;
    
    END IF;
    
    END LOOP;
    END;
    

    通过循环的方式插入200W数据,为了提高插入效率,1万条提交一次;

    导出数据方法

    import lombok.extern.slf4j.Slf4j;
    import org.junit.Test;
    
    import java.io.*;
    import java.sql.*;
    import java.util.LinkedList;
    import java.util.List;
    
    @Slf4j
    public class DataExportTest {
    
    
        public static final String URL = "jdbc:oracle:thin:@127.0.0.1:1521:xe";
        public static final String DRIVER = "oracle.jdbc.OracleDriver";
        public static final String PASSWORD = "youdasi";
        public static final String USERNAME = "youdasi";
    
        @Test
        public void exportTest() throws Exception {
    
            //初始化数据库连接
            Connection connection = initConnection();
            Statement statement = connection.createStatement();
    
            //FETCH_SIZE 的大小视具体情况而定
            statement.setFetchSize(1000);
    
            ResultSet resultSet = statement.executeQuery("SELECT * FROM TEST");
            ResultSetMetaData metaData = resultSet.getMetaData();
            
            long begin = System.currentTimeMillis();
            //数据库每行数据
            StringBuilder rowData = new StringBuilder();
    
            //单次写入文件的数据(可以删掉)
            List<String> pageData = new LinkedList<String>();
    
            //result 为数据库
            int j = 0;
            int num = metaData.getColumnCount();
            while (resultSet.next()){
                j++;
                //组装单行数据
                for (int i = 1; i< num ; i++){
                    Object object = resultSet.getObject(i);
                    if (null != object){
                        rowData.append(object.toString());
                    }
                    rowData.append("|");
                }
    
                pageData.add(rowData.toString());//添加到写文件集合
                rowData.setLength(0);//清空行数据
    
                //10W条数据写一次,视情况而定
                if (j % 100000 == 0){
                    log.info(j + "");
                    writeFile(pageData,"C:/temp/dat/test.dat");//写数据
                    pageData.clear(); //清空list
                }
            }
    
            if (j % 100000 != 0){
                writeFile(pageData,"C:/temp/dat/test.dat");//写数据
            }
    
            long end = System.currentTimeMillis();
            log.info("time: {}",end - begin);
        }
    
    
        /**
         * 初始化数据库连接
         */
        private Connection initConnection(){
    
            Connection connection = null;
    
            try {
                Class.forName(DRIVER);
                connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
            } catch (ClassNotFoundException e) {
                log.error("error load jdbc driver");
            } catch (SQLException e) {
                log.error("error get connection");
            }
            return connection;
        }
    
        /**
         * 写数据到文件
         */
        private void writeFile(List<String> data,String path) throws IOException {
    
            if (null == data || data.size() == 0){
                return;
            }
    
            File file = new File(path);
    
            if (!file.exists()){
                file.createNewFile();
            }
    
            FileOutputStream fileOutputStream = new FileOutputStream(path, true);
            OutputStreamWriter write = new OutputStreamWriter(fileOutputStream, "UTF-8");
            BufferedWriter writer = new BufferedWriter(write);
            for (String str:data){
                writer.write(str);
                writer.flush();
            }
            writer.close();
            write.close();
            fileOutputStream.close();
        }
    
    }
    

    代码中,有下面几个地方可以思考下:

    • FETCH_SIZE 取多大合适,我本地虚拟机docker起的ORACLE数据库,测试出1000比较合适,但是还是需要自己测试选择合适的;
    • PAGE_SIZE 取多少合适,也是需要视情况而定
    • 可以看出代码中有List pageData,这个其实可以直接省略掉,只用一个String,这样做其实只是让逻辑看起来清楚些,但是损耗了性能
    • 写文件的方法,每次新建了流再关闭,其实可以使用一个流,每次flush,最后一次再关闭就可以了,这样也可以提升部分效率
    • 代码中存在字符串的拼接,这个其实可以放到SQL中来做,这样就把字符拼接的工作从程序转移到数据库,至于哪个更好,不确定
    SELECT '字段名'||'字段名' AS RES_STR FROM '表名' WHERE ...;
    
    • 游标读取数据的时候,有用map封装的情况,改成数组效率会高很多,比如
            List<Map<Integer, String>> bufferData = new LinkedList<>();
                int rowNum = 0;
                while (resultSet.next()) {
                    rowNum++;
                    Map<Integer, String> rowData = new HashMap<>(num);
                    for (int i = 1; i < num; i++) {
                        rowData.put(i, resultSet.getString(i));
                    }
                    bufferData.add(rowData);
    
                }
    

    改为

                List<String[]> bufferData = new LinkedList<>();
                int rowNum = 0;
                while (resultSet.next()) {
                    String[] rowData = new String[num];
                    rowNum++;
                    for (int i = 1; i < num; i++) {
                        rowData[i] = resultSet.getString(i);
                    }
                    bufferData.add(rowData);
    
                }
    

    最终运行结果

    • 导出纪录数:200W
    • 导出文件大小:544 MB
    • 耗时 :29079ms=29s

    代码

    https://gitee.com/youdasixls/jdbc_export

    展开全文
  • 数据库脚本: -- Table "t_test" DDL CREATE TABLE `t_test` ( `id` int(11) NOT NULL AUTO_INCREMENT, `title` varchar(255) DEFAULT NULL, `createTime` bigint(20) DEFAULT NULL, PRIMARY KEY (`id`) ...

    数据库脚本:


    -- Table "t_test" DDL CREATE TABLE `t_test` ( `id` int(11) NOT NULL AUTO_INCREMENT, `title` varchar(255) DEFAULT NULL, `createTime` bigint(20) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    代码:

     

    package com.yanek.test; 
    import java.io.BufferedReader; 
    import java.io.File; 
    import java.io.FileOutputStream; 
    import java.io.FileReader; 
    import java.io.IOException; 
    import java.io.OutputStreamWriter; 
    import java.sql.Connection; 
    import java.sql.DriverManager; 
    import java.sql.PreparedStatement; 
    import java.sql.ResultSet; 
    import java.sql.SQLException; 
    import java.sql.Statement; 
    public class TestDB { 
      public static void main(String[] args) { 
       Test(); // 生成测试数据 
       //Exp(); 
       //Exp(0); 
       //System.out.println(readText("/opt/id.txt")); 
     
      /** 
       * 导出数据 
       */ 
       public static void Exp() { 
        Connection Conn= null
        try
         Class.forName( "com.mysql.jdbc.Driver" ).newInstance(); 
         String jdbcUrl = "jdbc:mysql://127.0.0.1:3306/testcms?characterEncoding=GBK"
         String jdbcUsername = "root"
         String jdbcPassword = "root"
         Conn = DriverManager.getConnection(jdbcUrl, jdbcUsername, jdbcPassword); 
         System.out.println( "conn" +Conn); 
         Exp(Conn); 
        } catch (SQLException e) { 
         e.printStackTrace(); 
       
        catch (InstantiationException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
        } catch (IllegalAccessException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
        } catch (ClassNotFoundException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
       
        finally 
       
         try
          Conn.close(); 
         } catch (SQLException e) { 
          // TODO Auto-generated catch block 
          e.printStackTrace(); 
        
       
      
       public static void Exp( int startid) { 
        Connection Conn= null
        try
         Class.forName( "com.mysql.jdbc.Driver" ).newInstance(); 
         String jdbcUrl = "jdbc:mysql://127.0.0.1:3306/testcms?characterEncoding=GBK"
         String jdbcUsername = "root"
         String jdbcPassword = "root"
         Conn = DriverManager.getConnection(jdbcUrl, jdbcUsername, jdbcPassword); 
         System.out.println( "conn" +Conn); 
         Exp(Conn,startid); 
        } catch (SQLException e) { 
         e.printStackTrace(); 
       
        catch (InstantiationException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
        } catch (IllegalAccessException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
        } catch (ClassNotFoundException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
       
        finally 
       
         try
          Conn.close(); 
         } catch (SQLException e) { 
          // TODO Auto-generated catch block 
          e.printStackTrace(); 
        
       
      
       /** 
       * 导出从startid开始的数据 
       * @param conn 
       * @param start_id 
       */ 
       public static void Exp(Connection conn, int start_id) { 
        int counter = 0
        int startid=start_id; 
        boolean flag = true
        while (flag) { 
         flag = false
         String Sql = "SELECT * FROM t_test WHERE id>" 
           + startid + " order by id asc LIMIT 50"
         System.out.println( "sql===" + Sql); 
         try
          Statement stmt = conn.createStatement(); 
          ResultSet rs = stmt.executeQuery(Sql); 
           while (rs.next()) { 
            flag = true
            int id = rs.getInt( "id" ); 
            String title = rs.getString( "title" ); 
            startid = id ; 
            counter++; 
            writeContent(counter+ "--id--" +id+ "--title-" +title+ "\r\n" , "/opt/" , "log.txt" , true ); 
            System.out.println( "i=" +counter+ "--id--" +id+ "--title-" +title); 
          
          rs.close(); 
          stmt.close(); 
         } catch (SQLException e) { 
          e.printStackTrace(); 
        
       
        writeContent( "" +startid, "/opt/" , "id.txt" , false ); 
      
       /** 
       * 导出一小时内的数据 
       * @param conn 
       */ 
       public static void Exp(Connection conn) { 
        int counter = 0
        //一小时内的数据 
        Long timestamp = System.currentTimeMillis() - ( 60 * 60 * 1000 ); 
        boolean flag = true
        while (flag) { 
         flag = false
         String Sql = "SELECT * FROM t_test WHERE createTime>" 
           + timestamp + " LIMIT 50"
         System.out.println( "sql===" + Sql); 
         try
          Statement stmt = conn.createStatement(); 
          ResultSet rs = stmt.executeQuery(Sql); 
          while (rs.next()) { 
           flag = true
           int id = rs.getInt( "id" ); 
           String title = rs.getString( "title" ); 
           Long lastmodifytime = rs.getLong( "createTime" ); 
           timestamp = lastmodifytime; 
           counter++; 
           System.out.println( "i=" +counter+ "--id--" +id+ "--title-" +title); 
         
          rs.close(); 
          stmt.close(); 
         } catch (SQLException e) { 
          e.printStackTrace(); 
        
       
      
       public static void Test() { 
        Connection Conn= null
        try
         Class.forName( "com.mysql.jdbc.Driver" ).newInstance(); 
         String jdbcUrl = "jdbc:mysql://127.0.0.1:3306/testcms?characterEncoding=GBK"
         String jdbcUsername = "root"
         String jdbcPassword = "root"
         Conn = DriverManager.getConnection(jdbcUrl, jdbcUsername, jdbcPassword); 
         System.out.println( "conn" +Conn); 
         for ( int i= 1 ;i<= 10000 ;i++) 
        
          add(Conn, "testTitle" +i+ "-" +System.currentTimeMillis()); 
        
        } catch (SQLException e) { 
         e.printStackTrace(); 
       
        catch (InstantiationException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
        } catch (IllegalAccessException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
        } catch (ClassNotFoundException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
       
        finally 
       
         try
          Conn.close(); 
         } catch (SQLException e) { 
          // TODO Auto-generated catch block 
          e.printStackTrace(); 
        
       
      
       public static void add(Connection conn,String title) 
      
        PreparedStatement pstmt = null
        String insert_sql = "insert into t_test(title,createTime) values (?,?)"
        System.out.println( "sql=" +insert_sql); 
        try
         pstmt = conn.prepareStatement(insert_sql); 
         pstmt.setString( 1 ,title); 
         pstmt.setLong( 2 ,System.currentTimeMillis()); 
         int ret = pstmt.executeUpdate(); 
        } catch (SQLException e) { 
         // TODO Auto-generated catch block 
         e.printStackTrace(); 
       
        finally
         try
          pstmt.close(); 
         } catch (SQLException e) { 
          // TODO Auto-generated catch block 
          e.printStackTrace(); 
         }  
       
      
       /** 
        * 写入内容到文件 
       
        * @param number 
        * @param filename 
        * @return 
        */ 
       public static boolean writeContent(String c, String dirname,String filename, boolean isAppend) { 
        File f= new File(dirname); 
        if (!f.exists()) 
       
          f.mkdirs(); 
       
        try
         FileOutputStream fos = new FileOutputStream( dirname+File.separator+filename,isAppend); 
         OutputStreamWriter writer = new OutputStreamWriter(fos); 
         writer.write(c); 
         writer.close(); 
         fos.close(); 
        } catch (IOException e) { 
         e.printStackTrace(); 
         return false
       
        return true
      
       /** 
        * 从文件读取内容 
       
        * @param filename 
        * @return 
        */ 
       public static String readText(String filename) { 
        String content = ""
        try
         File file = new File(filename); 
         if (file.exists()) { 
          FileReader fr = new FileReader(file); 
          BufferedReader br = new BufferedReader(fr); 
          String str = ""
          String newline = ""
          while ((str = br.readLine()) != null ) { 
           content += newline + str; 
           newline = "\n"
         
          br.close(); 
          fr.close(); 
        
        } catch (IOException e) { 
         e.printStackTrace(); 
       
        return content; 
      
    }

     

     

    基本思想: 就是通过记录开始记录id,执行多次sql来处理. 由于大数据量所以不能使用一条sql语句来输出.否则会内存不足导致错误.

    主要用途: 可以使用在做接口开发时,给第三方提供数据增量输出的场景使用.

    转载于:https://www.cnblogs.com/chenning/p/5030854.html

    展开全文
  • 利用itext操作pdf从数据库导出大量数据 压缩包含需要的jar包、案例源码
  • 今天我师傅让我写一个从数据库里的数据导出到Excel中并加密,开始我实现了只是用于一个类的,即一张的方法,但是这样不符合Java的面向对象的思想,并且复用性太低,经过不断的研究实现,终于实现了不同的类/均...

            今天我师傅让我写一个从数据库里的数据导出到Excel中并加密,开始我实现了只是用于一个类的,即一张表的方法,但是这样不符合Java的面向对象的思想,并且复用性太低,经过不断的研究实现,终于实现了不同的类/表均适用的方法,代码如下:

    public class TestExcel {
    
    	public  void encryptExportExcel(List<Map<String, Object>> list,String path,String[] title, String[] colum,Date oletime, Field[] fields) throws Exception {
                XSSFWorkbook wb = new XSSFWorkbook();
                XSSFSheet sheet1 = wb.createSheet("Rz_User");//自己命名
                XSSFRow row1 = sheet1.createRow(0);
               
                //设置表格样式
                XSSFCellStyle style = wb.createCellStyle();
                style.setAlignment(XSSFCellStyle.ALIGN_CENTER);//水平居中
                style.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);//垂直居中
            //  sheet1.addMergedRegion(new CellRangeAddress(0, 1, 0, 0));合并
                //设置类变量的行
                for (int i = 0; i < title.length; i++) {
                    sheet1.setColumnWidth(i,5000); //设置每列的宽,单位毫米
                    XSSFCell cell = row1.createCell(i);
                    cell.setCellValue(title[i]);
                    cell.setCellStyle(style);
                }
                for (int i = 0; i < list.size(); i++) {
                	row1 = sheet1.createRow(i+1);   	
                    	int k = 0;
                    	//利用Java的反射机制顺序获取变量
                    	for(Field field : fields) {
                			try {
                				field.setAccessible(true);
                				XSSFCell cell = row1.createCell(k);
                				cell.setCellValue(list.get(i).get(colum[i])==null?"":field.get(list.get(i).get(colum[i])).toString());;
                			    k++;
                			} catch (IllegalArgumentException e) {
                				e.printStackTrace();
                			}catch (IllegalAccessException e) {
                			    // TODO Auto-generated catch block
                			    e.printStackTrace();
                			   }
                    }
                }
                
                FileOutputStream fileOut = new FileOutputStream(path);
                wb.write(fileOut);
                fileOut.close();
                POIFSFileSystem fs = new POIFSFileSystem();
                EncryptionInfo info = new EncryptionInfo(EncryptionMode.agile);
                Encryptor enc = info.getEncryptor();
                enc.confirmPassword("123456");//设置打开密码
                OPCPackage opc = OPCPackage.open(new File(path), PackageAccess.READ_WRITE);
                OutputStream os = enc.getDataStream(fs);
                opc.save(os);
                opc.close();
                FileOutputStream fos = new FileOutputStream(path);
                fs.writeFilesystem(fos);
                fos.close();
        }
    }

            期间遇到的困难点是如何获取到类变量的值,如果想要适用于各个不同的类,显然是不能用set/get方法来获取的,故采用Java反射机制来获取即可,有点需要注意的是:field.setAccessible(true); 要设置为true,不然会报访问权限的错误。解决方法来自:https://blog.csdn.net/wangzai199701/article/details/78244082

            至于其他的代码块则主要是导出Excel并加密,网上都有,不懂的可以去搜索就行。

             下面是测试用的类:

    public class TestExcelData {
    
    	
    	public static void main(String args[]) throws Exception{
    		//假设从数据库里查出来的结果集
    		List<TestExcelUser> list = new ArrayList<>();
    		
    		List<Map<String, Object>> list2 = new ArrayList<>();
    		
    		//假设数据
    		TestExcelUser user = new TestExcelUser(1,"小明",18,new Date());
    		TestExcelUser user1 = new TestExcelUser(2,"小刘",18,new Date());
    		TestExcelUser user2 = new TestExcelUser(3,"小四",18,new Date());
    		TestExcelUser user3 = new TestExcelUser(4,"小李",18,new Date());
    		TestExcelUser user4 = new TestExcelUser(5,"小虎",18,new Date());
    		TestExcelUser user5 = new TestExcelUser(6,"小傻",18,new Date());
    		TestExcelUser user6 = new TestExcelUser(7,"小子",18,new Date());
    		
    		list.add(user);
    		list.add(user1);
    		list.add(user2);
    		list.add(user3);
    		list.add(user4);
    		list.add(user5);
    		list.add(user6);
    		
    		//这里是关键,将查出来的记录放在map中。
    		Map<String, Object> map = new HashMap<>();
    		//设一个数组里的值为key,其值对应一条记录
    		String[] colum = new String[list.size()];
    		for(int i = 0 ; i < list.size(); i++) {
    			map.put(""+i, list.get(i));
    			colum[i] = ""+i;
    			list2.add(map);
    		}
    
    		//假设文件路径
    		String  path = "C:\\Users\\admin\\Desktop\\rzjfforum.xlsx";
    		//假设每列的名称
    		String[] title = {"userid","username","age","time"};
    
    		//假设一个过期的时间...用于当某些数据过久远时可以删除掉
    		Date expriedTime = new Date();
    		
    		Field[] fields = TestExcelUser.class.getDeclaredFields();
    		
            //调用上面类的方法
    		TestExcel testExcel = new TestExcel();
    		testExcel.encryptExportExcel(list2, path, title, colum,user.getTime(),fields);
    
    	}
    }

           这里主要是如何将不同的类/表的结果集传过去,这里就用到了List和Map的组合,将每一条记录存放到Map中,而key的值用一个字符串数组来存储,在将Map存放到List即可。其中涉及到的过期时间,可以暂不考虑。

    展开全文
  • Java实现数据库批量导出到Excel

    千次阅读 2020-02-21 11:27:54
    前言:之前的博客介绍了Java实现Excel批量导入数据库,昨天二哈兄弟说为什么没有数据库导出到Excel的呢?所以此篇博客将主要针对数据库里面的数据导出到Excel 1.导出前分析 众所周知Alibaba提供了开源的EasyExcel...

    前言:之前的博客介绍了Java实现Excel批量导入数据库,昨天二哈兄弟说为什么没有数据库导出到Excel的呢?所以此篇博客将主要针对数据库里面的数据导出到Excel

    1.导出前分析

    众所周知Alibaba提供了开源的EasyExcel技术,该技术是针对Apache POI技术的封装和优化,主要解决了POI技术的耗内存问题,并且提供了较好的API使用。不需要大量的代码就可以实现excel的操作功能

    • 性能对比:POI对内存消耗很大,在处理大批量的数据时,容易造成内存溢出,比如比如处理一个 3M 的 Excel,poi 可能需要上百兆的内存,而 easyexcel 可能只需要几兆而已,所以在性能这一块, poi与EasyExcel是无法媲美的
    • 复杂度对比:POI需要自己对数据进行处理,尤其是对表格样式设计起来稍微有点复杂,所以造成开发的时候代码量很大;但是easyExcel能够自己处理数据,表格格式设计也简单

    不过现在使用POI进行数据操作的还是不占少数,所以此篇博客还是对于使用POI实现对数据库数据导出到Excel,关于使用easyExcel操作后序博客会有讲解

    2.首先数据库表里存储一些测试数据

    在这里插入图片描述

    3.配置pom以及application.properties

    这里我还是使用之前的Java实现Excel批量导入数据库的配置,就不做大的变动

    pom.xml

    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.1</version>
    </dependency>
    <!--java对象状态自动映射到关系数据库中数据上-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <!--实现类与xml之间的相互转换-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-oxm</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.2.12.Final</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-jpamodelgen</artifactId>
        <version>5.2.12.Final</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-jpa</artifactId>
        <version>2.2.3.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--前端页面我这里使用了thymeleaf模板引擎-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.12</version>
    </dependency>
    <!--使用POI读取文件-->
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>3.17</version>
    </dependency>
    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi-ooxml</artifactId>
        <version>3.17</version>
    </dependency>
    
    

    application.properties

    spring.datasource.username=123456
    spring.datasource.password=123456
    spring.datasource.url=jdbc:mysql://localhost:3306/excel?useUnicode=true&useSSL=false&characterEncoding=UTF-8&serverTimezone=UTC
    
    4.创建实体类 Excel
    package com.wxy.excel.entity;
    import java.io.Serializable;
    
    public class Excel implements Serializable {
    
        private String id;
        private String username;
        private String email;
        private String password;
        private String role;
    
        //此处省略getter,setter以及构造方法
    
    
    5.创建Dao层接口

    因为导出到Excel数据之前,需要将需要的数据查出来,所以此接口实现数据查询,这里为了方便直接通过@Select注解进行查询操作

    package com.wxy.excel.mapper;
    
    import com.wxy.excel.entity.Excel;
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Select;
    
    import java.util.List;
    
    @Mapper
    public interface UserMapper {
        @Select("select * from excel")
        List<Excel> getAllUser();
    }
    
    6.service层处理

    这里提供的接口,这里主要是通过HttpServletResponse 进行请求响应,由于HttpServletResponse是ServletResponse的子接口,功能和方法更加强大

    package com.wxy.excel.service;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    public interface ExcelService {
       
        /*数据库导出到Excel*/
        void exportExcel(HttpServletResponse response) throws IOException;
    }
    

    对以上接口实现,进行导出Excel的逻辑处理

    package com.wxy.excel.service;
    import com.wxy.excel.mapper.ExcelRepository;
    import com.wxy.excel.entity.Excel;
    import com.wxy.excel.mapper.UserMapper;
    import org.apache.poi.hssf.usermodel.*;
    import org.apache.poi.ss.usermodel.*;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.web.multipart.MultipartFile;
    import org.apache.poi.hssf.usermodel.HSSFCellStyle;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    
    @Service
    public class ExcelServiceImpl implements ExcelService{
        @Autowired
        private UserMapper userMapper;
    
        @Override
        public void exportExcel(HttpServletResponse response) throws IOException {
            // 第一步,创建一个webbook,对应一个Excel文件
            HSSFWorkbook wb = new HSSFWorkbook();
            // 第二步,在webbook中添加一个sheet,对应Excel文件中的sheet
            HSSFSheet sheet = wb.createSheet("test");
            // 第三步,在sheet中添加表头第0行,注意老版本poi对Excel的行数列数有限制short
            HSSFRow row = sheet.createRow(0);
            // 第四步,创建单元格,并设置值表头 设置表头居中
            HSSFCellStyle style = wb.createCellStyle();
            // 创建一个居中格式
            style.setAlignment(HorizontalAlignment.CENTER);
            /*此处根据情况自己自定义样式*/
    
            HSSFCell cell = row.createCell(0);
            cell.setCellValue("ID");
            cell.setCellStyle(style);
            cell = row.createCell(1);
            cell.setCellValue("姓名");
            cell.setCellStyle(style);
            cell = row.createCell(2);
            cell.setCellValue("邮箱");
            cell.setCellStyle(style);
            cell = row.createCell(3);
            cell.setCellValue("密码");
            cell.setCellStyle(style);
            cell = row.createCell(4);
            cell.setCellValue("角色");
            cell.setCellStyle(style);
    
            // 第五步,写入实体数据 实际应用中这些数据从数据库得到,
            List<Excel> list = userMapper.getAllUser();
    
            for (int i = 0; i < list.size(); i++) {
                row = sheet.createRow(i + 1);
                Excel excel = list.get(i);
                // 创建单元格,并设置值
                row.createCell(0).setCellValue(excel.getId());
                row.createCell(1).setCellValue(excel.getUsername());
                row.createCell(2).setCellValue(excel.getEmail());
                row.createCell(3).setCellValue(excel.getPassword());
                row.createCell(4).setCellValue(excel.getRole());
            }
            //第六步,输出Excel文件
            OutputStream output = response.getOutputStream();
            response.reset();
            //设置日期格式
            SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
            // 获取当前系统时间
            String fileName = df.format(new Date());
            //设置导出文件表头(即文件名)
            response.setHeader("Content-disposition", "attachment; filename=" + fileName + ".xls");
            //设置返回内容类型
            response.setContentType("application/msexcel");
            wb.write(output);
            output.close();
        }
    }
    
    7.controller层请求
    package com.wxy.excel.controller;
    import com.wxy.excel.service.ExcelService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.servlet.http.HttpServletResponse;
    import javax.xml.soap.SAAJResult;
    
    @Controller
    public class ExcelController {
    
        @Autowired
        private ExcelService excelService;
    
        @GetMapping("/export")
        public void exportExcel(HttpServletResponse response) {
            try {
                excelService.exportExcel(response);
                System.out.println("导出成功");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    8.浏览器请求进行数据导出

    浏览器请求地址 localhost:8080/export

    在这里插入图片描述

    打开下载文件效果如下:

    在这里插入图片描述

    结语:博客整理时难免会有些遗漏,已经项目Demo上传到github,地址https://github.com/Wangxy9527/ExcelToDatabase 包括数据库导出到excel以及Excel导入到数据库,上述文章,如有疑问欢迎留言,Common progress

    展开全文
  • 遇到一个需求,将一个数据库中的某个数据导入到另外一台服务器上的数据库,并且中包含blob字段,在使用kettle失败的情况下,shell脚本咱又不熟悉,作为一个java程序猿,紧急使用java的jdbc实现处理此业务,...
  • Java导出数据库查询结果为excel和csv的简易实现

    万次阅读 热门讨论 2016-12-04 23:43:03
    Java导出数据量的数据库查询结果为excel和csv的简易实现.
  • JAVA实现数据库数据导入/导出到Excel(POI) 准备工作: 1. 导入 POI 包:POI下载地址 http://mirrors.tuna.tsinghua.edu.cn/apache/poi/release/src/ (重要) 如下 2 .导入Java界面美化包 Beauty...
  • 使用Java应用程序导出Mysql 数据库里面的基本信息
  • 数据库导出大量数据记录保存到文件的方法和实例 数据库脚本: -- Table "t_test" DDL CREATE TABLE `t_test` (  `id` int(11) NOT NULL AUTO_INCREMENT,  `title` varchar(255) DEFAULT NULL,  `...
  • 利用itext操作pdf从数据库导出大量数据–创建PDF表格(三) 【原始需求】 通过SQL及JDBC模式导出各类业务数据,以PDF文件格式存放,要求该文件只能查看和打印(不能编辑和篡改),文件要有公司相关标志和水印功能...
  • Sybase数据库大量数据导出Excel

    千次阅读 2013-09-17 14:34:12
    应客户要求,导出数据库中的数据为Excel,只在一个Sheet中,Excel中的内容要与数据库里的内容一致(主要针对日期型数据)。  由于之前接触过POI,对POI的一些特性还是有一定的了解的,因此顺其自然的用POI去解决这...
  • Java Excel SXSSFWorkbook大量数据导出

    千次阅读 2017-04-13 16:41:14
    本文将介绍Java Excel SXSSFWorkbook大量数据导出的方法
  • Hive基础一(数据库,分区,视图,导入导出数据) Hive基础二(join原理和机制,join的几种类型,数据倾斜简单处理) Hive基础三(查询中常用的语法)注意Hive版本问题,可能有些命令不适用或者漏掉了。查看...
  • 数十万Excel数据快速导入导出数据库 写在前面:读取Excel先后试用了Alibaba的开源框架EasyExcel和比较经典的Poi。使用poi过程中也走了很多弯路,在这里就不记录了,我还是弃用吧。其中遇到的最大的问题就是内存...
  • 1.目前导出excel的几种格式:Excel 2003、Excel 2007 在POI中使用HSSF对象时,excel 2003最多只允许存储65536条数据,一般用来处理较少的数据量,这时对于百万级别数据,在计算机性能稍低的机器上测试,就很容易...
  • 加载数据库驱动程序是JDBC操作的第一步,而不同数据库的驱动程序路径是不一样的,MySQL中的数据库驱动程序是com.mysql.cj.jdbc.Driver(我用的是mysql-connector-java-8.0.12,而mysql-connector-java-5.0.4-bin.jar...
  • java如何实现数据从一个数据库(Oracle)导入到另一个数据库(SQL Server),有没有一些工具可以实现这样的功能?
  •  最近在应对一个数据查询导出模块,总体要求就是依据给定的SQL语句,输出其查询结果为csv或者xlsx文件。其中查询数据量可能会有大数据量,成百上千万都可能。 2.探讨  针对上述数据导出这个问题,提取出几个...
  • 如要导出数据库100万条数据,每次取1万条,这样分100次取,每次取的数量自己可以定义,保证内存不溢出。   具体例子和代码:   /** * 导出excel文件 * @param request * @param response * @...
  • 我们在写数据库设计文档的时候,会需要对数据库表进行设计的编写,手动写的话会很费时间费精力,尤其是如果有大量需要写的时候,就更加浪费时间了。下面就让我给大家讲一...
  • JAVA实现数据导出excel

    千次阅读 2018-12-25 14:36:20
    JAVA 实现数据导出操作时,如果采用POI直接导出,会出现内存溢出的情况。再者EXCEL的SHEET也存在行数的限制,Excel2003版最大行数是655536行、Excel2007版最大行数是1048576行、Excel2010版最大行数是1048576行...
  • [color=blue][size=large]在Java Web开发中,经常需要导出大量数据到Excel,使用POI、JXL直接生成Excel,很容易就造成内存溢出了。  1、有一种方式,就是把数据写成csv格式文件。  1)csv文件可以直接用...
  • 背景:由于之前程序是将图片以16进制数的形式直接保存到数据库的。现需要将图片批量导出所以写了下面的简易代码,供大家学习交流使用。 目的:将mssql数据库中类型为image的图片信息,导出到文件(*.jpg)
  • 大量数据导出到 Excel 的问题

    千次阅读 2018-11-20 18:36:53
    大量数据导出到 Excel 的问题-基于 POI常用导出方式比较内存消耗情况简单总结与分析测试代码: 常用导出方式 HSSFWorkbook SXSSFWorkbook 比较内存消耗情况 测试导出 6 万条记录,观察导出的过程中,...
  • Java集成Hutool实现导出Excel功能

    千次阅读 2019-08-16 14:35:19
    在工作中刚完成项目集成Hutool实现导出Excel功能,现在记录一下实现过程,方便以后作为例子参考。 Hutool简介 Hutool是一个Java工具包,也只是一个工具包,它帮助我们简化每一行代码,减少每一个方法,让Java语言也...
  • Spring-Boot实现Excel表数据导入数据库

    千次阅读 2018-12-05 12:00:14
    这次主要是实现历史学生信息导入功能,要求只是提示错误信息,将没错的导入; 好了,贴代码 pom导入依赖,貌似这个poi工具类不向下兼容 &amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,568
精华内容 8,227
关键字:

java代码实现导出数据库表大量数据

java 订阅