bean序列化到文件以及从文件取得被序列化的bean的方法

最新推荐文章于 2024-06-07 15:14:14 发布
原创 最新推荐文章于 2024-06-07 15:14:14 发布 · 1.3k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#bean #string #properties #null #exception #object

import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.util.Properties;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Caaaa {

 /**
  * 从properties配置文件中取得被序列化的bean
  *
  * @param request
  * @param cName
  * @return
  */
 public static Object getBeanFromcookie(HttpServletRequest request,
   String cName) {
  String cookieValue = readValue(request, cName);
  Object result = new Object();

  if (cookieValue == null || "".equals(cookieValue)) {
   return result;
  }

  try {
   String decoderCookieValue = java.net.URLDecoder.decode(cookieValue,
     "UTF-8");
   ByteArrayInputStream bais = new ByteArrayInputStream(
     decoderCookieValue.getBytes("ISO-8859-1"));
   ObjectInputStream ios = new ObjectInputStream(bais);
   result = (Object) ios.readObject();
  } catch (UnsupportedEncodingException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  }

  return result;
 }

 /**
  * bean序列化后保存到properties配置文件中
  *
  * @param bean
  * @param response
  * @param saveSearchBeanName
  * @param request
  */
 public static void saveBeanToCookie(Object bean,
   HttpServletResponse response, String saveSearchBeanName,
   HttpServletRequest request) {
  try {
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   ObjectOutputStream oos = new ObjectOutputStream(baos);
   oos.writeObject(bean);
   String cookieValue = baos.toString("ISO-8859-1");
   String encodedCookieValue = java.net.URLEncoder.encode(cookieValue,
     "UTF-8");
   setCookie(response, saveSearchBeanName, encodedCookieValue, request);

  } catch (IOException e) {
   e.printStackTrace();
  }
 }

 /**
  * 根据key读取value
  *
  * @param request
  * @param key
  * @return
  */
 public static String readValue(HttpServletRequest request, String key) {
  Properties props = new Properties();

  StringBuffer fileName = getFile(request);

  try {
   InputStream in = new BufferedInputStream(new FileInputStream(
     fileName.toString()));
   props.load(in);
   String value = props.getProperty(key);
   return value;
  } catch (IOException e) {
   e.printStackTrace();
   return null;
  }
 }

 /**
  * 取得文件名
  *
  * @param request
  * @return
  */
 public static StringBuffer getFile(HttpServletRequest request) {

  StringBuffer fileName = new StringBuffer(request.getSession()
    .getServletContext().getRealPath("/"));
  fileName.append("/xxxx/xxxx.properties");

  File file = new File(fileName.toString());
  if (!file.exists()) {
   try {
    file.createNewFile();
   } catch (IOException e) {
    e.printStackTrace();
   }
  }

  return fileName;
 }

 /**
  * 设置cookie
  *
  * @param response
  * @param cName
  * @param cValue
  */
 public static void setCookie(HttpServletResponse response, String cName,
   String cValue, HttpServletRequest request) {

  StringBuffer fileName = getFile(request);

  writeProperties(fileName.toString(), cName, cValue);
 }

 /**
  * 写入properties信息
  *
  * @param filePath
  * @param parameterName
  * @param parameterValue
  */
 public static void writeProperties(String filePath, String parameterName,
   String parameterValue) {
  Properties prop = new Properties();
  try {
   InputStream fis = new FileInputStream(filePath);
   // 从输入流中读取属性列表（键和元素对）
   prop.load(fis);
   // 调用 Hashtable 的方法 put。使用 getProperty 方法提供并行性。
   // 强制要求为属性的键和值使用字符串。返回值是 Hashtable 调用 put 的结果。
   OutputStream fos = new FileOutputStream(filePath);
   prop.setProperty(parameterName, parameterValue);
   // 以适合使用 load 方法加载到 Properties 表中的格式，
   // 将此 Properties 表中的属性列表（键和元素对）写入输出流
   prop.store(fos, "Update '" + parameterName + "' value");
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

 

 

 

如果要进行序列化的类实现了Serializable接口，则序列化和反序列化更加简单。

 

import java.io.Serializable;

public class TestBean implements Serializable {
    /**
     *
     */
    private static final long serialVersionUID = 8983605225929184344L;

    private String strStr;

    private String strStrss;

    private String consoleStr;

    private String password;

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getConsoleStr() {
        return consoleStr;
    }

    public void setConsoleStr(String consoleStr) {
        this.consoleStr = consoleStr;
    }

    public String getStrStrss() {
        return strStrss;
    }

    public void setStrStrss(String strStrss) {
        this.strStrss = strStrss;
    }

    public String getStrStr() {
        return strStr;
    }

    public void setStrStr(String strStr) {
        this.strStr = strStr;
    }
}

 

 

import java.io.Console;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

class animal {
    void eat() {
        System.out.print(" animal eat ");
    }
}

class horse extends animal {
    void eat(int a) {
        System.out.print(" horse eat ");
    }
}

public class test {
    public static void main(String args[]) {
        // animal a = new horse();
        // a.eat();
        //
        // animal b = new animal();
        // b.eat();
        TestBean tb = new TestBean();
        try {
            FileOutputStream fo = new FileOutputStream("bean.ser");
            ObjectOutputStream dataO = new ObjectOutputStream(fo);
            tb.setStrStr("(*^__^*) 嘻嘻……");
            tb.setStrStrss("O(∩_∩)O哈哈~");

            // 控制台
            Console co = System.console();
            String coStr = co.readLine();

            tb.setConsoleStr(coStr);           

            char password[] = co.readPassword();
       
            String pStr = "";
            for (char t: password) {
                pStr += t;
            }
            tb.setPassword(pStr);
            System.out.println(pStr);
            // 序列化
            dataO.writeObject(tb);

            FileInputStream fi = new FileInputStream("bean.ser");
            ObjectInputStream dataI = new ObjectInputStream(fi);
            // 反序列化
            TestBean tbI = (TestBean) dataI.readObject();

            System.out.println(tbI.getStrStr());
            System.out.println(tbI.getStrStrss());

            System.out.println("控制台输入的值");
            System.out.println(tbI.getConsoleStr());

            System.out.println("控制台输入的密码");
            System.out.println(tbI.getPassword());

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {

        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

 

 

序列化formbean到字符串

public String goIndex(ActionForm form, HttpServletRequest request,
            HttpServletResponse response) throws Exception {
        // formbean
        IntAir0006Form formBean = (IntAir0006Form) form;
        ByteArrayOutputStream bos = null;
        ZipOutputStream zos = null;
        ObjectOutputStream oos = null;
        try {
            // 字节数组输出流
            bos = new ByteArrayOutputStream();
            // 压缩方法
            zos = new ZipOutputStream(bos);
            zos.setMethod(ZipEntry.DEFLATED);
            zos.putNextEntry(new ZipEntry("a"));
            // 序列化
            oos = new ObjectOutputStream(zos);
            oos.writeObject(formBean);
            zos.closeEntry();

            // 转换编码
            String formBeanStr = new String(bos.toByteArray(), "ISO-8859-1");

            // 转换为 UTF-8
            String encodedCookieValue = java.net.URLEncoder.encode(formBeanStr,
                    "UTF-8");
            // 保存序列化的字符串
            formBean.setSerStr(encodedCookieValue);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            throw e;
        } catch (IOException e) {
            e.printStackTrace();
            throw e;
        } finally {
            try {
                if (bos != null) {
                    bos.close();
                }
                if (zos != null) {
                    zos.close();
                }
                if (oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
                throw e;
            }
        }

        return "";
    }

 

    /**
     *
     * 反序列化取得Form
     *
     * @param rBean
     * @return
     * @throws Exception
     */
    public static IntAir0006Form getFormFromStr(IntAir0006Form rBean)
            throws Exception {
        IntAir0006Form formBean = null;
        InputStream in = null;
        ZipInputStream zin = null;
        ObjectInputStream oin = null;

        try {
            // 按照UTF-8编码
            String decoderCookieValue = java.net.URLDecoder.decode(rBean
                    .getSerStr(), "UTF-8");
            // 取得字节数组
            byte[] data = decoderCookieValue.getBytes("ISO-8859-1");
            // 字节数组输入流
            in = new ByteArrayInputStream(data);
            // zip输入流 解压缩
            zin = new ZipInputStream(in);
            zin.getNextEntry();
            // 反序列化 取得formBean
            oin = new ObjectInputStream(zin);
            formBean = (IntAir0006Form) oin.readObject();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            throw e;
        } catch (IOException e) {
            e.printStackTrace();
            throw e;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            throw e;
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
                if (zin != null) {
                    zin.close();
                }
                if (oin != null) {
                    oin.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
                throw e;
            }
        }
        return formBean;
    }

cleanerq
关注
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 22万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
Bean保存成流文件，读取文件转换成bean
01-27
Bean保存成流文件，读取文件转换成bean
序列化与反序列化(文件存储到磁盘与读取文件到javaBean)
baseli的博客
03-13 2292
package test; import java.io.Serializable; public class Client implements Serializable{ /** * 生成序列号标识 */ private static final long serialVersionUID = -2083503801443301445L; p...
[Spring]Spring Bean的初始化 ---- getBean方法
HeapStackk的博客
07-21 1734
Spring 无论实在spring 容器在初始化阶段 还是 懒加载的bean 都是通过BeanFactory的getBean方法来实例化bean的。 getBean方法提供了多种方式来获取bean 可以通过bean的名字，bean的类型等。 但是他们最后都是调用的doGetBean(...)方法 protected T doGetBean( final String name, f
java beans xml_JavaBean-XML组件轻松实现JavaBeans到XML的相互转换
weixin_34766430的博客
02-16 113
import com.wutka.jox.*;import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException;public class BeanXMLMapping {/*** Retrieves a bean object for the* received...
java bean 序列化_java序列化和反序列化：Serializable
weixin_39789690的博客
02-16 1001
java序列化：Serializable需要了解：1、什么是java序列化和反序列化2、如何实现java序列化和反序列化3、什么时候需要序列化一、序列化和反序列化序列化：把对象转换为字节序列的过程称为对象的序列化。反序列化：把字节序列恢复为对象的过程称为对象的反序列化。序列化通俗的解释就是一类对象的集合，很多的对象数据，这些数据中，有些信息我们想让他持久的保存起来，就是把内存里面的这些对象给变成一...
jackson:基于BeanSerializer实现自定义的Java bean序列化器
10km的专栏
06-07 1011
之前写过一篇博客，介绍了如何继承实现自定义的反序列化器。如果要实现继承BeanDeserializer实现自定义的Java bean 解析器，与做序列化器一样，如何将一个Class转为构造方法需要的类型才是关键。
java bean 序列化_JAVA bean为何要实现序列化
weixin_31807925的博客
02-13 1049
简而言之：序列化，就是为了在不同时间或不同平台的JVM之间共享实例对象。即序列化出于两个原因：①、用于持久化到磁盘上；②、用于作为数据流在网络上传输。所谓的Serializable,就是java提供的通用数据保存和读取的接口。至于从什么地方读出来和保存到哪里去，都被隐藏在函数参数的背后了。这样，任何类型只要实现了Serializable接口，就可以被保存到文件中，或者作为数据流通过网络发送到别的地...
springcloud bean需要序列化码_对序列化中反射的一点思考
weixin_42300960的博客
01-12 662
前言序列化大家都不陌生，说白了就是把当前类对象的状态保存为二进制，然后被用来持久化或者网络传输；常用的RPC框架在数据传输前都会进行序列化操作，主流的RPC框架包含了多种序列化方式比如protobuf，fastjson，kryo，hessian，java内置序列化等等，大致可以分为二进制和字符串(json字符串)。反射因为需要把当前类对象状态保存为二进制，所以往往需要获取所有类属性，这时...
java bean 序列化_fastjson:javabean按字段(field)序列化存储为Map并反序列化
weixin_42522552的博客
02-16 404
大部分json工具对java对象整体序列化都提供了简单的调用方式，以fastjson为例：Model model = new Model();String json = JSON.toJSONString(model); // 序列化Model model2 = JSON.parSEObject(json,Model.class); // 反序列化需求说明最近的项目应用到redis数据库，需要将j...
bean序列化
03-22
bean序列化
实例解析Json反序列化之ObjectMapper(自定义实现反序列化方法)
10-19
在讨论Json反序列化过程中，我们通常会采用ObjectMapper类这一常用的工具。ObjectMapper是Jackson库中的一个核心类，它提供了丰富的API来处理JSON数据。在服务器端开发中，我们常常需要处理来自第三方接口的JSON数据...
SpringBoot Redis配置Fastjson进行序列化和反序列化实现
10-16
在`RedisConfiguration`类中，我们创建一个@Bean方法，用于初始化`RedisTemplate`并设置序列化器： ```java @Configuration public class RedisConfiguration { @Bean public RedisTemplate, Object> ...
springmvc fastjson 反序列化时间格式化方法(推荐)
10-20
接下来，在Spring MVC的配置文件（如`springMVC.xml`）中，替换原来的`FastJsonHttpMessageConverter`实例为我们的自定义类`JsonHttpMessageConverter`，并设置支持的媒体类型及序列化特性： ```xml <!-- 替换...
Java Bean与流文件间的序列化与反序列化
以下是基于上述知识点的Java代码示例，演示如何将一个Java Bean保存到文件，以及如何从文件中读取该Bean对象。 ```java import java.io.*; // Java Bean类 class TestBean implements Serializable { private ...
序列化、实体Bean序列化
学习那点事儿
06-11 8706
Java对象序列化： 1、 对象序列化：将一个对象转换成二级制数据流，如果一个类的对象要想实现对象序列化，则对象必须实现Serializable接口，该Serializable接口没有任何方法，此接口只是作为一个标识，表示本类的对象具备了序列化的能力而已。对象序列化是java的一个特征，通过该特征可以将对象写作一组字节码，当在其他位置读到这些字节码时，可以依此创建一个新的对象，而
组织架构和岗位职责.doc
最新发布
08-07
组织架构和岗位职责.doc
建业集团工程实测实量标准.doc
08-07
建业集团工程实测实量标准.doc
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值