深入浅出：java反射机制的应用器

首发于公众号：专业电影评论 专业影评

@TOC

java反射机制的应用器

开发的时候有时候会碰到这样的情况，我们在写程序的时候并不知道需要调用某个对象的哪个方法，只有程序运行后，我们才能够知道。或许我们需要根据客户端传过来的某个String 参数的值来判断我们应该执行哪个方法。在这种情况下JAVA 的反射执行就可以帮上忙了。下面是我做的一个简单的测试代码，提供给大家做个参考。

请看代码

import  java.lang.reflect.InvocationTargetException;
import  java.lang.reflect.Method;
/**
 *  @author  xiongdun
 *  测试 JAVA reflect 机制 
 */ 
public class TestRef {
    /**
    * @param args
    */ 
    public static void main(String[] args) {
        TestBean test = new TestBean();
        Method[] methods = test.getClass().getMethods();
        test.setAbc("---");
        for (int i = 0; i < methods.length; i++) {
            if (methods[i].getName().equalsIgnoreCase("getabc")) {
                try {
                    System.out.println(methods[i].invoke(test));
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

JAVA 反射机制

JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java 语言的反射机制。 Java 反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

  1. 得到某个对象的属性
public Object getProperty(Object owner, String fieldName) throws Exception {
    Class ownerClass = owner.getClass();
    Field field = ownerClass.getField(fieldName);
    Object property = field.get(owner);
    return property;
}

Class ownerClass = owner.getClass() # 得到该对象的Class 。
Field field = ownerClass.getField(fieldName) # 通过Class 得到类声明的属性。
Object property = field.get(owner) # 通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException 。

  1. 得到某个类的静态属性
public Object getStaticProperty(String className, String fieldName) throws Exception {
    Class ownerClass = Class.forName(className);
    Field field = ownerClass.getField(fieldName);
    Object property = field.get(ownerClass);
    return property;
}

Class ownerClass = Class.forName(className) ：首先得到这个类的Class 。
Field field = ownerClass.getField(fieldName) ：和上面一样，通过Class 得到类声明的属性。
Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class 里取。

  1. 执行某对象的方法
public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception { 
    Class ownerClass = owner.getClass();
    Class[] argsClass = new Class[args.length];
    for (int i = 0, j = args.length; i < j; i++) {
        argsClass[i] = args[i].getClass();
    }
    Method method = ownerClass.getMethod(methodName, argsClass);
    return method.invoke(owner, args);
}

Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class 。
5 ～9 行：配置参数的Class 数组，作为寻找Method 的条件。
Method method = ownerClass.getMethod(methodName, argsClass) ：通过Method 名和参数的Class 数组得到要执行的Method 。
method.invoke(owner, args) ：执行该Method ，invoke 方法的参数是执行这个方法的对象，和参数数组。返回值是Object ，也既是该方法的返回值。

  1. 执行某个类的静态方法
public Object invokeStaticMethod(String className, String methodName, Object[] args) throws Exception {
    Class ownerClass = Class.forName(className);
    Class[] argsClass = new Class[args.length];
    for (int i = 0, j = args.length; i < j; i++) {
        argsClass[i] = args[i].getClass();
    }
    Method method = ownerClass.getMethod(methodName, argsClass);
    return method.invoke(null, args);
}

基本的原理和实例3 相同，不同点是最后一行，invoke 的一个参数是null ，因为这是静态方法，不需要借助实例运行。

  1. 新建实例
public Object newInstance(String className, Object[] args) throws Exception {
    Class newoneClass = Class.forName(className);
    Class[] argsClass = new Class[args.length];
    for (int i = 0, j = args.length; i < j; i++) {
    argsClass[i] = args[i].getClass();
    }
    Constructor cons = newoneClass.getConstructor(argsClass);
    return cons.newInstance(args);
}

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance() 来实现。
Class newoneClass = Class.forName(className) ：第一步，得到要构造的实例的Class 。
第5 ～第9 行：得到参数的Class 数组。
Constructor cons = newoneClass.getConstructor(argsClass) ：得到构造子。
cons.newInstance(args) ：新建实例。

  1. 判断是否为某个类的实例
public boolean isInstance(Object obj, Class cls) {
    return cls.isInstance(obj);
}
  1. 得到数组中的某个元素
public Object getByArray(Object array, int index) {
    return Array.get(array,index);
}

Java 反射机制深入研究

Java 反射是 Java 语言的一个很重要的特征，它使得 Java 具体了 动态性 。
在 Java 运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于 Java 语言的反射（ Reflection ）机制。

Java 反射机制主要提供了以下功能：

  1. 在运行时判断任意一个对象所属的类。
  2. 在运行时构造任意一个类的对象。
  3. 在运行时判断任意一个类所具有的成员变量和方法。
  4. 在运行时调用任意一个对象的方法。

Reflection 是 Java 被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过 Reflection APIs 取得任何一个已知名称的 class 的内部信息，包括其 modifiers （诸如 public, static 等等）、 superclass （例如 Object ）、实现之 interfaces（例如 Serializable ），也包括 fields 和 methods 的所有信息，并可于运行时改变 fields 内容或调用 methods 。
一般而言，开发者社群说到动态语言，大致认同的一个定义是： “ 程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言” 。从这个观点看， Perl ， Python ， Ruby 是动态语言， C++ ， Java ， C# 不是动态语言。

尽管在这样的定义与分类下 Java 不是动态语言，它却有着一个非常突出的动态相关机制： Reflection 。这个字的意思是 “ 反射、映象、倒影 ” ，用在 Java 身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的 classes 。换句话说， Java 程序可以加载一个运行时才得知名称的 class ，获悉其完整构造（但不包括 methods 定义），并生成其对象实体、或对其 fields 设值、或唤起其methods 。这种 “ 看透 class” 的能力（ the ability of the program to examine itself ）被称为 introspection （内省、内观、反省）。 Reflection 和 introspection 是常被并提的两个术语。

在 JDK 中，主要由以下类来实现 Java 反射机制，这些类都位于 java.lang.reflect 包中：

Class 类：代表一个类。
Field 类：代表类的成员变量（成员变量也称为类的属性）。
Method 类：代表类的方法。
Constructor 类：代表类的构造方法。
Array 类：提供了动态创建数组，以及访问数组的元素的静态方法。
下面给出几个例子看看 Reflection API 的实际运用：

一、通过 Class 类获取成员变量、成员方法、接口、超类、构造方法等

在 java.lang.Object 类中定义了 getClass() 方法，因此对于任意一个 Java 对象，都可以通过此方法获得对象的类型。 Class 类是Reflection API 中的核心类，它有以下方法

  1. getName() ：获得类的完整名字。
  2. getFields() ：获得类的 public 类型的属性。
  3. getDeclaredFields() ：获得类的所有属性。
  4. getMethods() ：获得类的 public 类型的方法。
  5. getDeclaredMethods() ：获得类的所有方法。
  6. getMethod(String name, Class[] parameterTypes) ：获得类的特定方法， name 参数指定方法的名字
  7. parameterTypes 参数指定方法的参数类型。
  8. getConstructors() ：获得类的 public 类型的构造方法。
  9. getConstructor(Class[] parameterTypes) ：获得类的特定构造方法， parameterTypes 参数指定构造方法的参数类型。
  10. newInstance() ：通过类的不带参数的构造方法创建这个类的一个对象。

下面给出一个综合运用的例子：

public class RefConstructor {
    public static void main(String args[]) throws Exception {
        RefConstructor ref = new RefConstructor();
        ref.getConstructor();
    }
    public void getConstructor() throws Exception {
        Class c = null;
        c = Class.forName("java.lang.Long");
        Class cs[] = {java.lang.String.class};
        System.out.println("/n-------------------------------/n");
        Constructor cst1 = c.getConstructor(cs);
        System.out.println("1 、通过参数获取指定 Class 对象的构造方法： ");
        System.out.println(cst1.toString());
        Constructor cst2 = c.getDeclaredConstructor(cs);
        System.out.println("2 、通过参数获取指定 Class 对象所表示的类或接口的构造方法： ");
        System.out.println(cst2.toString());
        Constructor cst3 = c.getEnclosingConstructor();
        System.out.println("3 、获取本地或匿名类 Constructor 对象，它表示基础类的立即封闭构造方法。 ");
        if (cst3 != null) {
            System.out.println(cst3.toString());
        } else {
            System.out.println("-- 没有获取到任何构造方法！ ");
        }
        Constructor[] csts = c.getConstructors();
        System.out.println("4 、获取指定 Class 对象的所有构造方法： ");
        for (int i = 0; i < csts.length; i++) {
            System.out.println(csts[i].toString());
        }
        System.out.println("/n-------------------------------/n");
        Type types1[] = c.getGenericInterfaces();
        System.out.println("1 、返回直接实现的接口： ");
        for (int i = 0; i < types1.length; i++) {
            System.out.println(types1[i].toString());
        }
        Type type1 = c.getGenericSuperclass();
        System.out.println("2 、返回直接超类： ");
        System.out.println(type1.toString());
        Class[] cis = c.getClasses();
        System.out.println("3 、返回超类和所有实现的接口： ");
        for (int i = 0; i < cis.length; i++) {
            System.out.println(cis[i].toString());
        }
        Class cs1[] = c.getInterfaces();
        System.out.println("4 、实现的接口 ");
        for (int i = 0; i < cs1.length; i++) {
            System.out.println(cs1[i].toString());
        }
        System.out.println("/n-------------------------------/n");
        Field fs1[] = c.getFields();
        System.out.println("1 、类或接口的所有可访问公共字段： ");
        for (int i = 0; i < fs1.length; i++) {
            System.out.println(fs1[i].toString());
        }
        Field f1 = c.getField("MIN_VALUE");
        System.out.println("2 、类或接口的指定已声明指定公共成员字段： ");
        System.out.println(f1.toString());
        Field fs2[] = c.getDeclaredFields();
        System.out.println("3 、类或接口所声明的所有字段： ");
        for (int i = 0; i < fs2.length; i++) {
            System.out.println(fs2[i].toString());
        }
        Field f2 = c.getDeclaredField("serialVersionUID");
        System.out.println("4 、类或接口的指定已声明指定字段： ");
        System.out.println(f2.toString());
        System.out.println("/n-------------------------------/n");
        Method m1[] = c.getMethods();
        System.out.println("1 、返回类所有的公共成员方法： ");
        for (int i = 0; i < m1.length; i++) {
            System.out.println(m1[i].toString());
        }
        Method m2 = c.getMethod("longValue", new Class[]{});
        System.out.println("2 、返回指定公共成员方法： ");
        System.out.println(m2.toString());
    }
}

输出结果：输出结果很长，这里不再给出。

二、运行时复制对象

例程 ReflectTester 类进一步演示了 Reflection API 的基本使用方法。 ReflectTester 类有一个 copy(Object object) 方法，这个方法能够创建一个和参数 object 同样类型的对象，然后把 object 对象中的所有属性拷贝到新建的对象中，并将它返回

这个例子只能复制简单的 JavaBean ，假定 JavaBean 的每个属性都有 public 类型的 getXXX() 和 setXXX() 方法。

public class ReflectTester {
    public Object copy(Object object) throws Exception {
        // 获得对象的类型
        Class<?> classType = object.getClass();
        System.out.println("Class:" + classType.getName());
        // 通过默认构造方法创建一个新的对象
        Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
        // 获得对象的所有属性
        Field fields[] = classType.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            Field field = fields[i];
            String fieldName = field.getName();
            String firstLetter = fieldName.substring(0, 1).toUpperCase();
            // 获得和属性对应的 getXXX() 方法的名字
            String getMethodName = "get" + firstLetter + fieldName.substring(1);
            // 获得和属性对应的 setXXX() 方法的名字
            String setMethodName = "set" + firstLetter + fieldName.substring(1);
            // 获得和属性对应的 getXXX() 方法
            Method getMethod = classType.getMethod(getMethodName, new Class[]{});
            // 获得和属性对应的 setXXX() 方法
            Method setMethod = classType.getMethod(setMethodName, new Class[]{field.getType()});
            // 调用原对象的 getXXX() 方法
            Object value = getMethod.invoke(object, new Object[]{});
            System.out.println(fieldName + ":" + value);
            // 调用拷贝对象的 setXXX() 方法
            setMethod.invoke(objectCopy, new Object[]{value});
        }
        return objectCopy;
    }
    
    public static void main(String[] args) throws Exception {
        Customer customer = new Customer("Tom", 21);
        customer.setId(new Long(1));
        Customer customerCopy = (Customer) new ReflectTester().copy(customer);
        System.out.println("Copy information:" + customerCopy.getId() + " " + customerCopy.getName() + " " + customerCopy.getAge());
    }
}

class Customer {
    private Long id;
    private String name;
    private int age;
    
    public Customer() {

    }
    public Customer(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

输出结果：
Class:com.langsin.reflection.Customer
id:1
name:Tom
age:21
Copy information:1 Tom 21
Process finished with exit code 0

解说：
ReflectTester 类的 copy(Object object) 方法依次执行以下步骤
（ 1 ）获得对象的类型：
Class classType=object.getClass();
System.out.println("Class:"+classType.getName());
（ 2 ）通过默认构造方法创建一个新对象：
Object objectCopy=classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
以上代码先调用 Class 类的 getConstructor() 方法获得一个 Constructor 对象，它代表默认的构造方法，然后调用 Constructor 对象的 newInstance() 方法构造一个实例。
（ 3 ）获得对象的所有属性：
Field fields[]=classType.getDeclaredFields();
Class 类的 getDeclaredFields() 方法返回类的所有属性，包括 public 、 protected 、默认和 private 访问级别的属性
（ 4 ）获得每个属性相应的 getXXX() 和 setXXX() 方法，然后执行这些方法，把原来对象的属性拷贝到新的对象中

三、用反射机制调用对象的方法

public class InvokeTester {
    public int add(int param1, int param2) {
        return param1 + param2;
    }

    public String echo(String msg) {
        return "echo: " + msg;
    }

    public static void main(String[] args) throws Exception {
        Class<?> classType = InvokeTester.class;
        Object invokeTester = classType.newInstance();
        // Object invokeTester = classType.getConstructor(new
        // Class[]{}).newInstance(new Object[]{});
        // 获取 InvokeTester 类的 add() 方法
        Method addMethod = classType.getMethod("add", new Class[]{int.class, int.class});
        // 调用 invokeTester 对象上的 add() 方法
        Object result = addMethod.invoke(invokeTester, new Object[]{new Integer(100), new Integer(200)});
        System.out.println((Integer) result);
        // 获取 InvokeTester 类的 echo() 方法
        Method echoMethod = classType.getMethod("echo", new Class[]{String.class});
        // 调用 invokeTester 对象的 echo() 方法
        result = echoMethod.invoke(invokeTester, new Object[]{"Hello"});
        System.out.println((String) result);
    }
}

在例程 InvokeTester 类的 main() 方法中，运用反射机制调用一个 InvokeTester 对象的 add() 和 echo() 方法
add() 方法的两个参数为 int 类型，获得表示 add() 方法的 Method 对象的代码如下：


Method addMethod=classType.getMethod("add",new Class[]{int.class,int.class});

Method 类的 invoke(Object obj,Object args[]) 方法接收的参数必须为对象，如果参数为基本类型数据，必须转换为相应的包装类型的对象。 invoke() 方法的返回值总是对象，如果实际被调用的方法的返回类型是基本类型数据，那么 invoke() 方法会把它转换为相应的包装类型的对象，再将其返回。

在本例中，尽管 InvokeTester 类的 add() 方法的两个参数以及返回值都是 int 类型，调用 add Method 对象的 invoke() 方法时，只能传递 Integer 类型的参数，并且 invoke() 方法的返回类型也是 Integer 类型， Integer 类是 int 基本类型的包装类：
Object result=addMethod.invoke(invokeTester,
new Object[]{new Integer(100),new Integer(200)});
System.out.println((Integer)result); //result 为 Integer 类型

四、动态创建和访问数组

java.lang.Array 类提供了动态创建和访问数组元素的各种静态方法。

例程 ArrayTester1 类的 main() 方法创建了一个长度为 10 的字符串数组，接着把索引位置为 5 的元素设为 “hello” ，然后再读取索引位置为 5 的元素的值

public class ArrayTester1 {
    public static void main(String args[]) throws Exception {
        Class<?> classType = Class.forName("java.lang.String");
        // 创建一个长度为 10 的字符串数组
        Object array = Array.newInstance(classType, 10);
        // 把索引位置为 5 的元素设为 "hello"
        Array.set(array, 5, "hello");
        // 获得索引位置为 5 的元素的值
        String s = (String) Array.get(array, 5);
        System.out.println(s);
    }
}

例程 ArrayTester2 类的 main() 方法创建了一个 5 x 10 x 15 的整型数组，并把索引位置为 [3][5][10] 的元素的值为设 37 。

public class ArrayTester2 {
    public static void main(String args[]) {
        int[] dims = new int[]{5, 10, 15};
        // 创建一个具有指定的组件类型和维度的新数组。
        Object array = Array.newInstance(Integer.TYPE, dims);
        Object arrayObj = Array.get(array, 3);
    
        Class<?> cls = arrayObj.getClass().getComponentType();
        System.out.println(cls);
        arrayObj = Array.get(arrayObj, 5);
        Array.setInt(arrayObj, 10, 37);
        int arrayCast[][][] = (int[][][]) array;
        System.out.println(arrayCast[3][5][10]);
    }
}

深入认识 Class 类

众所周知 Java 有个 Object 类，是所有 Java 类的继承根源，其内声明了数个应该在所有 Java 类中被改写的方法： hashCode() 、equals() 、 clone() 、 toString() 、 getClass() 等。其中 getClass() 返回一个 Class 类的对象。

Class 类十分特殊。它和一般 classes 一样继承自 Object ，其实体用以表达 Java 程序运行时的 classes 和 interfaces ，也用来表达 enum 、 array 、 primitive Java types（ boolean, byte, char, short, int, long, float, double ）以及关键词 void 。当一个 class 被加载，或当加载器（ class loader）的 defineClass() 被 JVM 调用， JVM 便自动产生一个 Class object 。如果您想借由 “ 修改 Java 标准库源码 ” 来观察 Class object 的实际生成时机（例如在 Class 的 constructor 内添加一个 println() ），不能够！因为 Class 并没有 public constructor
Class 是 Reflection 起源。针对任何您想探勘的 class ，唯有先为它产生一个 Class object ，接下来才能经由后者唤起为数十多个的Reflection APIs

Java 允许我们从多种途径为一个 class 生成对应的 Class 对象。参看本人的《 深入研究 java.long.Class 类 》一文。

欲生成对象实体，在 Reflection 动态机制中有两种作法，一个针对 “ 无自变量 ctor” ，一个针对 “ 带参数 ctor” 。如果欲调用的是 “带参数 ctor“ 就比较麻烦些，不再调用 Class 的 newInstance() ，而是调用 Constructor 的 newInstance() 。首先准备一个Class[] 做为 ctor 的参数类型（本例指定为一个 double 和一个 int ），然后以此为自变量调用 getConstructor() ，获得一个专属 ctor 。接下来再准备一个 Object[] 做为ctor 实参值（本例指定 3.14159 和 125 ），调用上述专属 ctor 的 newInstance() 。

动态生成 “Class object 所对应之 class” 的对象实体；无自变量。
这个动作和上述调用 “ 带参数之 ctor” 相当类似。首先准备一个 Class[] 做为参数类型（本例指定其中一个是 String ，另一个是Hashtable ），然后以此为自变量调用 getMethod() ，获得特定的 Method object 。接下来准备一个 Object[] 放置自变量，然后调用上述所得之特定 Method object 的 invoke() 。

为什么获得 Method object 时不需指定回返类型？

因为 method overloading 机制要求 signature 必须唯一，而回返类型并非 signature 的一个成份。换句话说，只要指定了method 名称和参数列，就一定指出了一个独一无二的 method 。

四、运行时变更 field 内容

与先前两个动作相比， “ 变更 field 内容 ” 轻松多了，因为它不需要参数和自变量。首先调用 Class 的 getField() 并指定 field 名称。获得特定的 Field object 之后便可直接调用 Field 的 get() 和 set() 。

public class RefFiled  {
    public double x;
    public Double y;
    public static void main(String args[]) throws NoSuchFieldException, IllegalAccessException {
        Class c = RefFiled.class;
        Field xf = c.getField("x");
        Field yf = c.getField("y");
        RefFiled obj = new RefFiled();
        System.out.println(" 变更前 x=" + xf.get(obj));
        // 变更成员 x 值
        xf.set(obj, 1.1);
        System.out.println(" 变更后 x=" + xf.get(obj));
        System.out.println(" 变更前 y=" + yf.get(obj));
        // 变更成员 y 值
        yf.set(obj, 2.1);
        System.out.println(" 变更后 y=" + yf.get(obj));
    }
}

运行结果：
变更前 x=0.0
变更后 x=1.1
变更前 y=null
变更后 y=2.1

    Process finished with exit code 0
    private static Object check(Object obj,String flag) throws Exception {
        Class ts = obj.getClass();
        Field[] fs = ts.getDeclaredFields();
        Method[] ms = ts.getDeclaredMethods();
        StringBuffer fd = new StringBuffer();
        Map<String,Object> getMethodMap=new HashMap<String,Object>();
        Map<String,Method> setMethodMap=new HashMap<String,Method>();

        String methodName="";
        String value="";
        for(int i = 0;i < fs.length; i++) {
            if (java.lang.String.class != fs[i].getType()) {
                fd.append(fs[i].getName());

            }
        }

        for (int i = 0;i < ms.length; i++) {
            methodName=ms[i].getName().toLowerCase();
                if (methodName.indexOf("get") != -1) {
                    getMethodMap.put(methodName.substring(3), ms[i].invoke(obj, null));
                } else {
                    setMethodMap.put(methodName.substring(3), ms[i]);
                }
            }
            Set keySet = getMethodMap.keySet();
            Iterator it = keySet.iterator();
            String key = "";
            while (it.hasNext()) {
                key = it.next().toString();
                if (fd.indexOf(key) == -1 && getMethodMap.get(key) != null) {
                    value=getMethodMap.get(key).toString().replaceAll(",", "").replaceAll(" ", "");
                    if("".equals(value)||flag.equals(value)) {
                        ((Method) setMethodMap.get(key)).invoke(obj, new Object[]{null});                              
                    } else {
                        ((Method) setMethodMap.get(key)).invoke(obj, new Object[]{value});                                  
                    }
                }
            }
        }
    }
    return obj;
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,732评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,496评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,264评论 0赞 338
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,807评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,806评论 5赞 368
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,675评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,029评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,683评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 41,704评论 1赞 299
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,666评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,773评论 1赞 332
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,413评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,016评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,978评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,204评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,083评论 2赞 350
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,503评论 2赞 343

推荐阅读更多精彩内容