Spring复习

spring概念：

1.spring是开源的轻量级框架

2.spring核心主要俩部分：
（1）aop：面向切面编程，扩展功能不是修改源代码实现
（2）ioc：控制反转

  • 比如有一个类，在类里面有方法（非静态类方法），调用类里面的方法，创建类的对象，使用对象调用方法，创建类的对象的过程，需要new出来对象。
  • 把对象不是通过new方式实现，而是交给spring配置创建类对象

3.spring是一站式框架
（1）spring在javaee三层结构中，每一层都提供不同的解决技术

  • web层：springMVC
  • service层：spring的ioc
  • dao层：spring的jdbcTemplate

4.spring版本
（1）hibernate5.x
（2）spring4.x

spring的ioc操作：
1.把对象的创建交给spring进行管理

2.ioc操作俩部分：
（1）ioc的配置文件方式(xml文件)
（2）ioc的注解方式

IOC底层原理：（面试会问）
1.ioc底层原理使用技术
（1）xml配置文件
（2）dom4j解析xml
（3）工厂设计模式
（4）反射

IOC入门案例：
第一步 导入jar包
jar特点：三个 文档，源代码
导入5个jar包：beans context core expression 还有commons-logging
第二步 创建一个类，在类里面创建方法

第三部 创建spring配置文件，配置创建类
（1）spring核心配置 文件名称和位置不固定

  • 建议放到src下面 官方建议：applicationContext.xml
    （2）引入schema约束
    第四部 写代码测试对象的创建

配置文件没有提示：

3.spring的bean管理(xml配置文件)

  • 在spring里面通过配置文件创建对象
1.bean实例化的三种方式

第一种 使用类的无参构造创建(重点)
类里面没有无参数的构造，出现异常
<bean id = "bean" class = "com.ghw.spring.Bean">
第二种 使用静态工厂创建
创建静态的方法，返回类对象
<bean id = "bean" class = "com.ghw.spring.BeanFactory" factory-method="getBean"></bean>
第三种 使用实例工厂创建
创建一个不是静态的方法，返回类对象
<bean id = "beanfactory" class = "com.ghw.spring.BeanFactory"></bean>
<bean id = "bean" class = "com.ghw.spring.Bean" factory-bean="beanfactory" factory-method="getBean"></bean>
第二种和第三种一般不用，一般只用第一种

2.Bean标签的常用属性
  1. id属性：起名称，id属性值名称任意，
  • id属性值,不能包含特殊符号,中文,下划线也不可以
  • 根据id值得到配置对象

  1. class属性：创建对象所在类的全路径

  2. name属性：功能和id类似 name属性值可以包含特殊符号,#_都可以
    一般不用，历史遗留问题

  3. scope属性：Bean的作用范围

  • singleton：默认值，单例的


    singleton.png

  • prototype：多例的


    prototype.png

    后三个了解

  • request：创建对象把对象放到request域里面
  • session：创建对象把对象放到session域里面 (保存登陆)
  • globalSession：创建对象把对象放到globalSession域里面
    登陆百度文库，在百度贴吧不需要重新登陆(单点登陆)
    redis数据库
  • factory属性一般不用
3.属性注入方式介绍
  1. 创建对象向类里面的属性设置值，类似set方法，有参构造方法，接口
  2. 属性注入的三种方式
    java中的三种：set方法，有参构造，接口(实现接口，重写方法set方法)
4.spring注入属性
  • spring框架中只支持前面俩种
  • set用的最多

使用有参构造方法注入属性:

<constructor-arg name="name" value="有参构造方法"></constructor-arg>

使用set方法注入属性:

<property name="name" value="set方法"></property>
5.注入对象类型属性(重点)
  1. 创建service类和Dao类
    （1）在service得到dao对象
  2. 具体实现过程
    （1）在service里面定义一个Dao类型的属性
public class Service {
    private Dao dao;
}

（2）生成Dao类型属性的set方法(也可以用有参构造)

public void setDao(Dao dao) {
        this.dao = dao;
    }

（3）配置文件完成注入过程

<bean id="service" class="com.ghw.spring.Service">
    <property name="dao" ref="dao"></property>
</bean>
<bean id="dao" class="com.ghw.spring.Dao"></bean>

ref是对象的引用

6.p名称空间注入
<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns:p="http://www.springframework.org/schema/p"   
    <bean id="service" class="com.ghw.spring.Service" p:name = "pname"> 
</beans>
7.spring注入复杂类型数据
  1. 数组
  2. list集合
  3. map集合
  4. properties类型
    代码如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="service" class="com.ghw.spring.Service">

        <!-- 数组 -->
        <property name="arrs">
            <list>
                <value>李书豪</value>
                <value>程宇轩</value>
                <value>祝上杰</value>
            </list>
        </property>

        <!-- List -->
        <property name="list">
            <list>
                <value>list1</value>
                <value>list2</value>
                <value>list3</value>
            </list>
        </property>

        <!-- Map -->
        <property name="map">
            <map>
                <entry key="map1" value="mapvalue1"></entry>
                <entry key="map2" value="mapvalue2"></entry>
                <entry key="map3" value="mapvalue3"></entry>
            </map>
        </property>

        <!-- properties -->
        <property name="properties">
            <props>
                <prop key="driverclass">com.mysql.jdbc.Driver</prop>
                <prop key="username">root</prop>
            </props>
        </property>
    </bean>

</beans>

package com.ghw.spring;

import java.util.List;
import java.util.Map;
import java.util.Properties;

public class Service {

    private String arrs[];
    private List<String> list;
    private Map<String, String> map;
    private Properties properties;

    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void print() {
        for (int i = 0; i < arrs.length; i++) {
            System.out.println("arrs[" + i + "]:" + arrs[i]);
        }
        System.out.println("list:" + list);
        System.out.println("map:" + map);
        System.out.println("properties:" + properties);
    }
}

IOC和DI区别

  1. IOC：控制反转，把对象创建交给spring进行配置
  • 创建对象
  1. DI：依赖注入，向类里面的属性设置值
  • 设置属性
  1. 关系：依赖注入不能单独存在，需要在IOC基础上

Spring整合Web项目原理：

  1. 加载spring核心配置文件
    （1）new对象，功能可以实现，效率很低

  2. 实现思想：把加载配置文件和创建对象过程，在服务器启动时候完成。

  3. 实现原理：(掌握)
    （1）ServletContext对象
    （2）监听器(代码不掌握，原理需要掌握)
    （3）具体使用

  • 在服务器启动时候，为每个项目创建一个ServletContext对象
  • 在ServletContext对象创建时候，使用监听器可以监听到ServletContext对象在什么时候创建
  • 使用监听器监听到ServletContext对象创建的时候
  • 加载spring配置文件，把配置文件配置对象创建
  • 把创建出来的对象放到ServletContext域对象里面(setAttribute方法)
  • 获取对象时候，到ServletContext域得到(getAttribute方法)

day-02

1.spring的bean管理(注解):

注解介绍：

  1. 代码里面特殊标记，使用注解可以完成功能
  2. 注解写法 @注解名称(属性名称=属性值)
  3. 注解使用在类，方法，属性上面
spring注解开发准备：

  1. 导入jar包
    （1）导入基本的jar包


    导入基本的jar包.png

（2）导入aop的jar包

导入aop的jar包.png

  1. 创建类，创建方法

  2. 创建spring的配置文件
    （1）第一天做ioc基本功能，引入约束是beans
    （2）做spring的注解开发，引入新的约束

新的约束.png
  1. 开启注解扫描
<!-- 开启注解扫描 
(1)到包里面扫描类、方法、属性上面是否有注解 -->
<context:component-scan base-package="com.ghw.anno"></context:component-scan>

<!-- 只扫描属性上面的注解 -->
<context:annotation-config></context:annotation-config>
注解创建对象

  1. 在创建对象的类上面使用注解实现


    注解实现.png

  2. 创建对象的注解(以及Component的三个衍生注解)

  • @Componen：
  • @Controller：WEB层
  • @Service：业务层 记住
  • @Repository：持久层
    四个注解功能一样，都用来创建对象
@Component(value = "user")
public class User {
    public void add() {
        System.out.println("add ........");
    }
}

3.创建对象单实例还是多实例

@Scope(value="prototype")  //singleton单实例
public class User {
    public void add() {
        System.out.println("add ........");
    }
}
注解注入属性

  1. 创建service类，创建dao类，在service得到dao对象
    注入属性第一个注解@AutoWired


    @AutoWired.png

注入属性第二个注解@Resource name要和传入对象的值一样

  • 常用，可以指定注入什么对象


    @Resource.png
package com.ghw.anno;

import org.springframework.stereotype.Component;

@Component(value = "userdao")
public class UserDao {
    public void add() {
        System.out.println("UserDao.....");
    }
}

package com.ghw.anno;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service(value = "userservice")
public class UserService {

    @Autowired
    private UserDao userdao;

    public void add() {
        System.out.println("UserService.....");
        userdao.add();
    }
}

（3）xml配置文件和注解方式混合使用

  1. 创建对象操作使用配置文件实现
<bean id="bookservice" class="com.ghw.xmlanno.BookService"></bean>
<bean id="bookdao" class="com.ghw.xmlanno.BookDao"></bean>
<bean id="ordersdao" class="com.ghw.xmlanno.OrdersDao"></bean>
  1. 注入属性操作使用注解方式实现
//注解扫描方式下面俩种
<context:component-scan base-package="com.ghw.xmlanno"></context:component-scan>
<context:annotation-config></context:annotation-config>

public class BookService {
    @Resource(name = "bookdao")
    private BookDao bookdao;
    @Autowired
    private OrdersDao ordersdao;

2. AOP概念

（1）aop概述
  1. aop:面向切面（方面）编程，扩展功能不修改源代码实现
  2. aop采取横向抽取机制，取代了传统纵向继承体系重复性代码
（2）aop底层原理

有接口，平级动态代理
没有接口，子类动态代理

（3）aop操作相关术语（掌握3个术语）
image.png

Pointcut（切入点）：所谓切入点是指我们要对哪些Joinpoint进行拦截的定义
通俗解释：在类里面可以有很多的方法被增强，比如实际操作中，只是增强了类里面的add方法和update方法，实际增强的方法称为切入点
Advidce（通知/增强）：所谓通知是指拦截到Joinpoint之后所要做的事情就是通知，通知分前置通知，后置通知，异常通知，最终通知，环绕通知（切面要完成的功能）
通俗解释：增强的逻辑，称为增强，比如扩展日志功能，这个日志功能称为增强
前置通知：在方法之前执行
后置通知：在方法之后执行
异常通知：方法出现异常
最终通知：在后置之后执行
环绕通知：在方法之前和之后都执行
Aspect（切面）：是切入点和通知（引介）的结合
通俗解释：把增强应用到具体的方法上面，过程称为切面
连接点：类里面哪些方法可以被增强，这些方法称为连接点

使用表达式配置切入点

  1. 切入点：实际增强的方法
  2. 常用表达式
    execution(<访问修饰符>?<返回类型><方法名>(<参数>)(<异常>)
    常用的：
    （1）execution(* com.ghw.aop.Book.add(..))
    增强指定的add方法
    （2）execution(* com.ghw.aop.Book.(..))
    增强Book类中所有方法
    （3）execution(     .(..))
    增强所有方法
    （4）execution(* save*(..))
    增强save开头的方法

3.spring的aop操作(基于aspectj的xml方式)

AspectJ的aop操作

  1. 配置对象
<!-- 1.配置类 -->
<bean id="book" class="com.ghw.aop.Book"></bean>
<bean id="mybook" class="com.ghw.aop.MyBook"></bean>
  1. 创建增强方法
package com.ghw.aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class MyBook {

    public void before1() {
        System.out.println("Book的前置增强");
    }

    public void after1() {
        System.out.println("Book的后置增强");
    }

    public void huanrao(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {

        System.out.println("环绕增强之前");
        proceedingJoinPoint.proceed();
        System.out.println("环绕增强之后");
    }
}
  1. 配置aop操作
<!-- 2.配置aop -->
<aop:config>
    <aop:pointcut expression="execution(* com.ghw.aop.Book.add(..))"
        id="pointcut1" />
    <aop:aspect ref="mybook">

        <aop:before method="before1" pointcut-ref="pointcut1" />
        <aop:after method="after1" pointcut-ref="pointcut1" />
        <aop:around method="huanrao" pointcut-ref="pointcut1"/>
    </aop:aspect>
</aop:config>

4. log4j介绍

  1. 通过log4j可以看到程序运行过程中更详细的信息
    （1）经常使用log4j查看日志

  2. 使用
    （1）导入log4j的jar包

image.png

（2）复制log4j的配置文件，复制到src下面

image.png
  1. 设置日志级别：
log4j.rootLogger=info,stdout

日志级别：
info 最基本日志
debug 可以看更详细日志

5.Spring整合web项目演示

  1. 演示问题
    （1）action调用service，service调用dao

Spring_day03

1.基于AspectJ注解的aop操作（会用）
需要知道的点：
  1. 要在 Spring 应用中使用 AspectJ 注解, 必须在 classpath 下包含 AspectJ 类库: aopalliance.jar、aspectj.weaver.jar 和 spring-aspects.jar
  2. 将 aop Schema 添加到 根元素中.
  • AspectJ 支持 5 种类型的通知注解:
    @Before: 前置通知, 在方法执行之前执行
    @After: 后置通知, 在方法执行之后执行
    @AfterRunning: 返回通知, 在方法返回结果之后执行
    @AfterThrowing: 异常通知, 在方法抛出异常之后
    @Around: 环绕通知, 围绕着方法执行
具体步骤：

第一步 创建对象

<!-- 第一步创建对象 -->
<bean id="book" class="com.ghw.aop.Book"></bean>
<bean id="mybook" class="com.ghw.aop.MyBook"></bean>

第二步 在spring配置文件中，开启aop操作

<!-- 第二步配置自动为匹配 aspectJ 注解的 Java 类生成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

第三步 在增强类上面使用注解完成aop操作，在方法上面使用注解完成增强配置

注解完成aop操作.png
2.spring的 jdbcTemplate操作
  • 实现crud操作
  • 增加、修改、删除，调用模板update方法
  • 查询某个值时候，调用queryForObject方法
    --- 自己写实现类封装数据
  • 查询对象，调用queryForObject方法
  • 查询list集合，调用query方法

  1. spring框架一站式框架
    （1）针对javaee三层，每一层都有解决技术
    （2）在dao层，使用 jdbcTemplate

  2. spring对不同的持久化层技术都进行封装
    （1）jdbcTemplate对jdbc进行封装

ORM持久化技术
  1. jdbcTemplate使用和dbutils使用很相似，都数据库进行crud操作

jdbcTemplate演示

第一个 增加
  1. 导入jdbcTemplate使用的jar包还有数据库驱动jar包
image.png
  1. 创建对象，设置数据库信息
// 设置数据库的信息
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///spring_day03");
dataSource.setUsername("root");
dataSource.setPassword("root");
  1. 创建 jdbcTemplate对象，设置数据源
// 创建jdbcTemplate对象
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
  1. 调用 jdbcTemplate对象里面的方法实现操作
image.png
// 调用jdbcTemplate里面的方法实现update方法
String sql = "insert into user values(?,?)";
int rows = jdbcTemplate.update(sql, "gouge", "250");
System.out.println(rows);  //输出更改的条数
第二个 删除
public void delete() {
    // 删除操作
    // 设置数据库的信息
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql:///spring_day03");
    dataSource.setUsername("root");
    dataSource.setPassword("root");
    // 创建jdbcTemplate对象
    JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
    // 调用jdbcTemplate里面的方法实现update方法
    String sql = "delete from user where username=?";
    int rows = jdbcTemplate.update(sql, "gouge");
    System.out.println(rows);
}
第三个 修改
public void update() {
    // 修改操作
    // 设置数据库的信息
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql:///spring_day03");
    dataSource.setUsername("root");
    dataSource.setPassword("root");
    // 创建jdbcTemplate对象
    JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
    // 调用jdbcTemplate里面的方法实现update方法
    String sql = "update user set password=? where username = ?";
    int rows = jdbcTemplate.update(sql, "1314", "gouge");
    System.out.println(rows);
}
第四个 查询

1.使用 jdbcTemplate实现查询操作

image.png
  1. 查询具体实现
    第一个 查询返回某一个值
image.png

（1）第一个参数是sql语句
（2）第二个参数 返回类型的class

    public void testCount() {
        // 查询操作
        // 设置数据库的信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring_day03");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        // 创建jdbcTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        // 调用方法得到记录数
        String sql = "select count(*) from user";
        // 调用jdbcTemplate方法
        int count = jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.println(count);
    }

Jdbc实现

Jdbc实现.png

第二个 查询返回对象

image.png

第一个参数是sql语句
第二个参数是 RowMapper，是接口，类似于dbutils里面接口
第三个参数是 可变参数

public void testCount() {
    // 查询操作
    // 设置数据库的信息
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql:///spring_day03");
    dataSource.setUsername("root");
    dataSource.setPassword("root");
    // 创建jdbcTemplate对象
    JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

    // 写sql语句，根据username查询
    String sql = "select * from user where username = ?";
    // 调用jdbcTemplate方法实现
    // 第二个参数是RowMapper，需要自己写类实现接口，自己做数据封装.
    User user = jdbcTemplate.queryForObject(sql, new MyrowMapper(), "tom");
    System.out.println(user);
}


class MyrowMapper implements RowMapper<User> {

    public User mapRow(ResultSet rs, int num) throws SQLException {
        User user = new User();
        // 从结果里面得到数据
        String username = rs.getString("username");
        String password = rs.getString("password");
        // 把得到的数据封装到对象里面
        user.setUsername(username);
        user.setPassword(password);
        return user;
    }
}

第三个 查询返回list集合

image.png

（1）sql语句
（2）RowMapper接口，自己写类实现数据封装
（3）可变参数

public void testCount() {
    // 查询操作
    // 设置数据库的信息
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql:///spring_day03");
    dataSource.setUsername("root");
    dataSource.setPassword("root");
    // 创建jdbcTemplate对象
    JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

    // 写sql语句，根据username查询
    String sql = "select * from user";
    // 调用jdbcTemplate方法实现
    // 第二个参数是RowMapper，需要自己写类实现接口，自己做数据封装.
    List<User> list = jdbcTemplate.query(sql, new MyrowMapper());
    System.out.println(list);
}


class MyrowMapper implements RowMapper<User> {

    public User mapRow(ResultSet rs, int num) throws SQLException {
        User user = new User();
        // 从结果里面得到数据
        String username = rs.getString("username");
        String password = rs.getString("password");
        // 把得到的数据封装到对象里面
        user.setUsername(username);
        user.setPassword(password);
        return user;
    }
}
3.Spring配置连接池和dao使用jdbcTemplate
  1. spring配置c3p0连接池
    第一步 导入jar包
导入jar包.png

第二步 创建spring配置文件，配置连接池

image.png

（1）把代码在配置文件中进行配置

<!-- 配置c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <!-- 注入属性值 -->
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql:///spring_day03"></property>
    <property name="user" value="root"></property>
    <property name="password" value="root"></property>
</bean>
  1. dao使用jdbcTemplate
    （1）创建service和dao，配置service和dao对象，在service注入dao对象
<!-- 创建Service对象，在service中注入dao对象 -->
<bean id="userservice" class="com.ghw.c3p0.UserService">
    <property name="userdao" ref="userdao"></property>
</bean>
<!-- 创建Dao对象，在dao中注入jdbctemplate对象 -->
<bean id="userdao" class="com.ghw.c3p0.UserDao">
    <property name="jdbcTemplate" ref="jdbctemplate"></property>
</bean>

（2）创建jdbcTemplate对象，在dao里面注入模板对象jdbctemplate

<!-- 创建Dao对象，在dao中注入jdbctemplate对象 -->
<bean id="userdao" class="com.ghw.c3p0.UserDao">
    <property name="jdbcTemplate" ref="jdbctemplate"></property>
</bean>
<!-- 创建jdbcTemplate对象-->
<bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate"></bean>

（3）在jdbcTemplate对象里面注入dataSource

<!-- 在jdbctemplate中注入dataSource对象 -->
<bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"></property>
</bean>
image.png
4.spring事务管理

（1）事务概念
（2）spring进行事务管理api

  • spring针对不同的dao层框架提供不同的实现类
    （3）spring进行事务配置（声明式）
  • 基于xml配置文件
  • 基于注解方式
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 217,185评论 6赞 503
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,652评论 3赞 393
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 163,524评论 0赞 353
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,339评论 1赞 293
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,387评论 6赞 391
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,287评论 1赞 301
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,130评论 3赞 418
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,985评论 0赞 275
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,420评论 1赞 313
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,617评论 3赞 334
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,779评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,477评论 5赞 345
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,088评论 3赞 328
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,716评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,857评论 1赞 269
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,876评论 2赞 370
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,700评论 2赞 354

推荐阅读更多精彩内容

  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 134,654评论 18赞 139
  • 超全面 spring 复习总结笔记
    前言 最近感触颇深，原谅我在开头写心情日记。介意的跳过看正文。 市场 趋势 近几年，技术市场对新人越来越不友好，社...
    IT天宇阅读 12,276评论 5赞 68
  • Spring中常见面试题
    什么是Spring Spring是一个开源的Java EE开发框架。Spring框架的核心功能可以应用在任何Jav...
    jemmm阅读 16,462评论 1赞 133
  • Spring boot参考指南
    Spring Boot 参考指南 介绍 转载自:https://www.gitbook.com/book/qbgb...
    毛宇鹏阅读 46,807评论 6赞 342
  • 是的，我27，8了
    l姑娘今天离职了。一晃四年，认识她是在大学教学楼的连廊背单词的日子。毕业后来到现在这家号称全国前三的民企，从什么都...
    来自长江边的猫阅读 121评论 0赞 1