精华内容
下载资源
问答
  • 将对象序列化存到redis缓存中

    千次阅读 2017-10-22 00:43:32
    //将对象序列化 static public byte [] toByteArray (Object obj) { byte [] bytes = null ; ByteArrayOutputStream bos = new ByteArrayOutputStream(); try { ObjectOutputStream oos = new ...

    当前spring框架提供了完整的redis缓存的注解支持,只要在方法前面加上注解@Cacheable
    直接去访问这个方法就会自动获取缓存。但是
    会存在一种这样的需求就是你不想去访问这方法
    就可以当前缓存中数据。 这个时候你可以自
    己写方法去获取当前缓存key值的对应缓存的
    数据。一下是我写的手动去获取我存在缓存中的
    hashMap和删除hashMap中的数据,其中
    hashmap被封装在类中,该类需要实现序列化接口,
    再将该类序列化保存到缓存中。

    package com.bisa.hkshop.zj.component;
    
    import java.io.Serializable;
    import java.util.HashMap;
    import java.util.Map;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.dao.DataAccessException;
    import org.springframework.data.redis.connection.RedisConnection;
    import org.springframework.data.redis.core.RedisCallback;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    
    import com.bisa.health.appserver.utils.CacheUtity;
    import com.bisa.hkshop.zj.basic.utility.BaseDelayed;
    import com.bisa.hkshop.zj.basic.utility.DelayOrderDto;
    
    @Component
    public class OrderRedisImp implements IOrderRedis{
    
        @Autowired
        private RedisTemplate redisTemp;
    
        //获取所有redis中所有的order
        @Override
        public HashMap<String,BaseDelayed<String>> getOrderRedis() {//对象换成你自己
            DelayOrderDto order;
            if(redisTemp.hasKey("order")){
                        order = (DelayOrderDto) redisTemp.execute(new RedisCallback<Object>() {
                        public Object doInRedis(RedisConnection connection) throws DataAccessException {
                            String sms_key = "order";
                            byte[] value = connection.get(sms_key.getBytes());
                            if(value.length>0){
                                return CacheUtity.toObject(value);
                            }else{
                                return "";
                            }
                        }
                    });
              return  order.getDelaylist();
            }
            return null;
        }
    
    
        //添加到缓存
        public void addOrderRedis(BaseDelayed<String> delayed) { //对象是你自己的
            /**
             * 将order存到redis缓存
             */
            //对象换成你自己
            HashMap<String,BaseDelayed<String>> delayList = this.getOrderRedis();
            if(delayList==null){
                delayList = new HashMap<String,BaseDelayed<String>>();
            }
            delayList.put(delayed.getValue(), delayed);
    
            DelayOrderDto order = new DelayOrderDto();
            order.setDelaylist(delayList); //存到封装好的map中
    
            redisTemp.execute(new RedisCallback<Boolean>() {
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    String sms_key = "order";
                    connection.setEx(sms_key.getBytes(), 3600, CacheUtity.toByteArray(order));
                    return true;
                }
            });
    
    
        }
            //删除缓存中某个order
        public void delOrderRedis(BaseDelayed<String> delayed) {
            /*
             * 将delay从redis中的删除
             */
            HashMap<String,BaseDelayed<String>> delayList = this.getOrderRedis();
            delayList.remove(delayed.getValue());
            DelayOrderDto order = new DelayOrderDto();
            order.setDelaylist(delayList); //存到封装好的HashMap中
            redisTemp.execute(new RedisCallback<Boolean>() {
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    String sms_key = "order";
                    connection.setEx(sms_key.getBytes(), 3600, CacheUtity.toByteArray(order));
                    return true;
                }
            });
    
        }
    
    
    
    }

    下面是关于序列化的两个方法:

    package com.bisa.health.appserver.utils;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    public class CacheUtity {
        //将对象序列化
        static public byte[] toByteArray(Object obj) {
            byte[] bytes = null;
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            try {
                ObjectOutputStream oos = new ObjectOutputStream(bos);
                oos.writeObject(obj);
                oos.flush();
                bytes = bos.toByteArray();
                oos.close();
                bos.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
            return bytes;
        }
    //反序列化
        static public  Object toObject(byte[] bytes) {
            Object obj = null;
            try {
                ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
                ObjectInputStream ois = new ObjectInputStream(bis);
                obj = ois.readObject();
                ois.close();
                bis.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            } catch (ClassNotFoundException ex) {
                ex.printStackTrace();
            }
            return obj;
        }
    }
    
    展开全文
  • fastJson将对象序列化成json字符串

    千次阅读 2018-06-16 13:01:53
    JSON_OBJ_STR = "{"studentName":"lily","studentAge":12}"; JSON_ARRAY_STR = "[{"studentName":...NotWriteDefaultValue,比如studentName为空的时候,序列化成json字符串就是{"studentAge":"21"},没有sthdentName
    JSON_OBJ_STR = "{"studentName":"lily","studentAge":12}";
    JSON_ARRAY_STR = "[{"studentName":"lily","studentAge":12},{"studentName":"lucy","studentAge":15}]";

    COMPLEX_JSON_STR="{"teacherName":"crystall","teacherAge":27,"course":{"courseName":"english","code":1270},"students":[{"studentName":"lily","studentAge":12},{"studentName":"lucy","studentAge":15}]}";

    字符串转json对象:JSONObject jsonObject = JSON.parseObject(JSON_OBJ_STR);

    字符串转json数组:JSONArray jsonArray = JSON.parseArray(JSON_ARRAY_STR);

    字符串转复杂json对象(嵌套):JSONObject jsonObject = JSON.parseObject(COMPLEX_JSON_STR);

    获取嵌套里面的对象:JSONObject innerObject = jsonObject.getJSONObject("xxx");

    json字符串转javaBean:Student student = JSON.parseObject(JSON_OBJ_STR, new TypeReference<Student>() {});

    复杂对象同上一样转;

    javaBean 转json字符串:String bookjson = JSONObject.toJSONString(book, SerializerFeature.WriteNullStringAsEmpty, SerializerFeature.WriteNullBooleanAsFalse);

    上面的SerializerFeature有好多枚举类型,上面的是null值写成“”,还有空值不写进字符串的

    SerializerFeature.NotWriteDefaultValue,比如studentName为空的时候,序列化成json字符串就是{"studentAge":"21"},没有sthdentName






    展开全文
  • 摘要:Java将对象序列化成为JSON格式、JSON格式反序列化为Java对象。 一:引入jackson的依赖: &lt;dependency&gt; &lt;groupId&gt;org.codehaus.jackson&lt;/groupId&gt; &lt;...

    摘要:Java将对象序列化成为JSON格式、JSON格式反序列化为Java对象。

    一:引入jackson的依赖:

    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>1.9.12</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-core-asl</artifactId>
      <version>1.9.12</version>
    </dependency>

    二:编写实体对象类Employee

    package cn.micai.base.io;
    
    import java.io.Serializable;
    
    /**
     * 描述:
     * <p>
     *
     *     transient使用小结
     *     1.一旦变量被transient修饰,变量将不再是对象持久化的一部分,该变量内容在序列化后无法获得访问。
     *     2.transient关键字只能修饰变量,而不能修饰方法和类。注意,本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量,则该类需要实现Serializable接口。
     *     3.被transient关键字修饰的变量不再能被序列化,一个静态变量不管是否被transient修饰,均不能被序列化。
     *
     * @author: 赵新国
     * @date: 2018/6/7 12:10
     */
    public class Employee implements Serializable {
    
        private static final long serialVersionUID = 1L;
        private int employeeId;
        private String employeeName;
        /**
         * 使用transient关键字,表示该字段不序列化
         */
        private transient String department;
    
        public int getEmployeeId() {
            return employeeId;
        }
        public void setEmployeeId(int employeeId) {
            this.employeeId = employeeId;
        }
        public String getEmployeeName() {
            return employeeName;
        }
        public void setEmployeeName(String employeeName) {
            this.employeeName = employeeName;
        }
        public String getDepartment() {
            return department;
        }
        public void setDepartment(String department) {
            this.department = department;
        }
    
        @Override
        public String toString() {
            return "Employee{" +
                    "employeeId=" + employeeId +
                    ", employeeName='" + employeeName + '\'' +
                    ", department='" + department + '\'' +
                    '}';
        }
    }
    

    三:编写使用jackson-all.1.7.6.jar工具包实现将对象序列化为JSON格式、JSON格式反序列化为对象的类

    package cn.micai.base.io;
    
    import org.codehaus.jackson.JsonFactory;
    import org.codehaus.jackson.JsonGenerator;
    import org.codehaus.jackson.map.ObjectMapper;
    
    import java.io.IOException;
    import java.io.StringWriter;
    
    /**
     * @Auther: zhaoxinguo
     * @Date: 2018/8/23 12:03
     * @Description: 使用jackson-all.1.7.6.jar工具包实现将对象序列化为JSON格式、JSON格式反序列化为对象
     */
    public class JacksonAllSerializeDeserializeMain {
    
        /**
         * 将Java对象employee序列化成为JSON格式
         * @param employee
         * @return
         */
        public static String serialize(Employee employee){
            // JSON对象序列化
            String employeeJson = null;
            try {
                ObjectMapper objectMapper = new ObjectMapper();
                StringWriter stringWriter = new StringWriter();
                JsonGenerator jsonGenerator = new JsonFactory().createJsonGenerator(stringWriter);
                objectMapper.writeValue(jsonGenerator, employee);
                jsonGenerator.close();
                employeeJson = stringWriter.toString();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return employeeJson;
        }
    
        /**
         * 将JSON格式反序列化为employee对象
         * @param employeeJson
         * @return
         */
        public static Employee deserialize(String employeeJson) {
            try {
                ObjectMapper objectMapper = new ObjectMapper();
                return objectMapper.readValue(employeeJson, Employee.class);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        public static void main(String [] args) {
    
            Employee employee = new Employee();
            employee.setEmployeeId(1);
            employee.setEmployeeName("赵新国");
            employee.setDepartment("软件工程师");
            // 序列化
            String serialize = serialize(employee);
            System.out.println(serialize);
            // 反序列化
            Employee deserialize = deserialize(serialize);
            System.out.println(deserialize);
    
        }
    
    }

    四:运行结果:

    展开全文
  • redis将对象序列化存储

    千次阅读 2016-04-25 20:48:26
    redis是一种nosql的语言,常用来作为缓存,... 编写序列化工具类,大家应该都不默认,序列化,就是流化,其转为字节码byte,然后我们一般是通过对象流来实现的 package com.jedis.aisainfo; import java.io.Byte

    redis是一种nosql的语言,常用来作为缓存,而且redis是一种高性能的存储架构,是以key value方式存储

         这里通过jedis来序列化对象来存入redis中

     编写序列化工具类,大家应该都不默认,序列化,就是流化,将其转为字节码byte,然后我们一般是通过对象流来实现的

    package com.jedis.aisainfo;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.util.ArrayList;
    import java.util.List;
    
    public class SerializeUtil {
        
        /**
         * 序列化
         * @param list
         * @return
         */
        public static byte[] serialize(List<User> list){
            //申明存放数组
            byte[] arr = null;
            //对象流,用于序列化对象
            ObjectOutputStream os = null;
            //临时输入流
            ByteArrayOutputStream bos=null;
            try {
                bos = new ByteArrayOutputStream();
                os = new ObjectOutputStream(bos);
                os.writeObject(list);
                arr=bos.toByteArray();
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return arr;
        }
        
        /**
         * 反序列化
         * @param in
         * @return
         */
        public static List<User> unserialize(byte[] in){
            
            List<User> list = null;
            //临时输入流
            ByteArrayInputStream bis = null;
            //读取对象流
            ObjectInputStream ois =null;
            
            try {
                list = new ArrayList<User>();
                
                
                bis = new ByteArrayInputStream(in);
                
                
                ois = new ObjectInputStream(bis);
                
                list = (List<User>)ois.readObject();
                
                
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                try {
                    ois.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            return list;
        }
    }
    
    
    
    序列化的对象:  
    package com.jedis.aisainfo;
    
    import java.io.Serializable;
    
    public class User implements Serializable{
    	
        private Integer id;
    
        private String username;
    
        private Integer age;
    
    	public Integer getId() {
    		return id;
    	}
    
    	public void setId(Integer id) {
    		this.id = id;
    	}
    
    	public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username == null ? null : username.trim();
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    }
    测试类:
               private Jedis jedis=null;
           
           @Before
           public void init(){
               jedis = new Jedis("localhost");
           }           
    
               @Test 
    	   public void addObjectInfo(){
    		   List<User> list = new ArrayList();
    		   User user1 = new User();
    		   user1.setAge(1);
    		   user1.setUsername("曾孟良");
    		   user1.setId(1);
    		   
    		   User user2 = new User();
    		   user2.setAge(1);
    		   user2.setUsername("陆燕");
    		   user2.setId(1);
    		   
    		   list.add(user1);
    		   list.add(user2);
    		   jedis.set("user".getBytes(), SerializeUtil.serialize(list));
    	   }
    	   
    	   @Test
    	   public void queryObjectInfo(){
    		   byte[] users = jedis.get("user".getBytes());
    		   List<User> list = SerializeUtil.unserialize(users);
    		   for(User user:list){
    			   System.out.println(user.getUsername());
    			   System.out.println(user.getId());
    		   }
    	   }

    先执行addObjectInfo,然后queryObjectInfo

    结果:

    曾孟良
    1
    陆燕
    1
    


    展开全文
  • 对象序列化不是对象转化成字节存入硬盘或者文件数据库中吗?和socket传输有什么关系呢?谢谢,小白不是很懂
  • /**  * 将对象序列化成,并编码成UTF-8的字符串  * @throws IOException  * @date 2015-4-3 下午3:31:37  */  private String serializeRovinceCities(List> result) throws IOE
  • java将对象对象集合序列化成string

    千次阅读 2019-06-03 10:56:05
    java将对象对象集合序列化成string 一、介绍 在日常java开发中,可能需要java中的对象转化成String类型进行存储在数据库或者Redis中。自己可能很难完成这个转化的过程,所以使用以下代码工具类进行快速转化。 ...
  • Java对象序列化(Serialization)和反序列化详解

    万次阅读 多人点赞 2018-02-13 15:56:02
    序列化(Serialization)是将对象的状态信息转化为可以存储或者传输的形式的过程,一般一个对象存储到一个储存媒介,例如档案或记忆体缓冲等,在网络传输过程中,可以是字节或者XML等格式;而字节或者XML格式的...
  • Java对象序列化详解

    万次阅读 多人点赞 2016-08-10 14:47:32
    一、定义 序列化:把Java对象转换为字节序列的过程。    反序列化:把字节序列恢复为Java对象的过程。二、用途 对象序列化主要有两种用途:    1) 把对象的字节序列永久地保存到硬盘上,通常存放在一...
  • ///  /// XMLHelper  ///  public static class XMLHelper  {  ///  /// 反序列化  ///  /// 类型  /// XML字符串  ///  public static objec
  • //把对象的原始信息和图形保存到文件中 序列化 Person p=new Person(1,"小红",'女'); ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream(new File("D:\\p.txt"))); out.writeObject(p); ...
  • 将对象序列化到文件 1.对象需要实现Seralizable接口 public class StudentBean implements Serializable { ······ } 2.通过ObjectOutputStream的writeObject()方法写入和ObjectInputStream的readObject...
  • 如何一个java对象序列化到文件里?

    千次阅读 2019-03-06 10:56:30
    在java中能被序列化的类必须实现Serializable接口,该接口没有任何抽象方法只是起到一个标记作用. ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream("D://obj")); ...
  • 将对象序列化成为一个byte数组

    千次阅读 2011-07-17 16:21:30
    但是死活存不进去,首先怀疑自己是不是哪里用错了,但是查看代码并没有什么不妥之处,当时还在怪memcached怎么这么二,居然自己不会序列化一个对象,同事说他用byte数组一些图片存放进去过,于是我
  • 定义一个学生信息类 身高tall为静态属性 输出为99  static属性定义在类文件中之后,在其他类中调用该...在进行序列化的时候,序列化其实上是对象最后一次状态的改变,也就是把内存中的对象的状态持久化到了文件中。
  • 对象序列化成字节数组

    千次阅读 2018-07-28 22:58:47
    所以对象p实现序列化接口Serializable ByteArrayOutputStream ba=new ByteArrayOutputSream(); ObjectOutputStream oos=new ObjectOutputSream(ba); oos.writeObject(p); byte[] pBytes=ba.toByteArray(); 把...
  • Java基础——对象序列化(通俗易懂,排版优美)

    千次阅读 多人点赞 2018-05-23 23:31:23
    Java基础——对象的序列化什么是对象的序列化...通过对象序列化,可以方便的实现对象的持久化储存以及在网络上的传输。大致的过程如下图所示: 对象被转换成“字节流”后可以存入文件,内存,亦或者是数...
  • 可能就需要用到两种方式来解析传输数据,对应数据格式的字节位来解析,或者是采用数据序列化与反序列化的方式来解析。个人比较倾向于后者的方式,毕竟以前做过Java或C#的项目。也觉得用这种方式比较方便省事。所以就...
  • js之对象序列化

    千次阅读 2019-10-06 15:05:34
    什么是对象序列化 对象的状态转换成字符串 对象的状态信息转换为可以存储或传输的形式的过程 为什么会有对象序列化 希望把对象obj的内容保存在磁盘上 — 对象obj序列化 序列化:obj的内容转换成一个字符串的...
  • 摘要:Java对象序列化成XML格式,XML反序列化还原为Java对象。 一:创建Maven工程,引入xstream依赖: &lt;!--xstream--&gt; &lt;dependency&gt; &lt;groupId&gt;...
  • java将对象序列化为字节数组

    千次阅读 2019-11-23 15:55:29
    public static byte[] ser(Object obj) throws IOException{ ByteArrayOutputStream baos =new ByteArrayOutputStream(); ObjectOutputStream oos =new ObjectOutputStream(baos); oos.writeObject(obj);...
  • 这是一个用C#写的Socket服务器和客户端,当然Socket服务器和客户端不是主要的(有兴趣的朋友可以参考下),主要的内容是介绍如何通过这种Socket方式发送Object对象。 作者博客 http://luyugao.com
  • 对象序列化的几种方式的比较

    千次阅读 2016-09-04 19:43:50
    比较常见的做法有两种:一是把对象包装成JSON字符串传输,二是采用java对象序列化和反序列化。随着Google工具protoBuf的开源,protobuf也是个不错的选择。对JSON,Object Serialize,ProtoBuf 做个对比。 定义...
  • C#序列化对象转为为XML格式字符串

    千次阅读 2020-07-07 21:42:19
    实习公司原来的左侧菜单是通过js进行ajax请求一个xml文件得到一个xml对象,然后拼接html文件,现在需要从...3、变量这个Dictionary,根据每个key生成一个对象,这个对象的属性是个List,List中包含的事子菜单的对象
  • Qt中对象序列化的实现

    千次阅读 2016-01-04 19:45:39
    参考资料 [1]Qt持久性对象进行序列化 [2]Qt中序列化对象 [3]对象的序列化和反序列化 [4]JAVA对象序列化保存为XML文件的工具类
  • 对象流实现对象序列化和反序列化 import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import ...
  • 《 Effective Java 》中序列化一节关于java的序列化存在如下说法:对象序列化(object serialization)API,它提供了一个框架,用来对象编码成字节流(serializing),并从字节流编码中重新构建对象(deserializing)。...
  • Unity对象序列化原理介绍

    千次阅读 2019-10-09 21:02:43
    Unity使用了很多年了,在这里我敢说很多人对Unity对象序列化原理并不是很清楚,比如Asset与Object之间有啥区别?如何管理Asset?Unity的序列化是咋回事等等,下面就从Asset与Object对象区别说起。 Asset与对象 先...
  • //序列化对象,写入ms流中 byte[] bytes = ms.GetBuffer(); return bytes; } public static object DeserializeObject(byte[] bytes) { object obj = null; if (bytes == null) return obj; //利用...
  • 序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间,对象将其当前状态写入到临时或持久性存储区。以后,可以通过从存储区中读取或反序列化对象的状态,重新创建该对象。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 680,698
精华内容 272,279
关键字:

怎么将对象序列化