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配置文件
  • 基于注解方式
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • Spring Cloud為開發人員提供了快速構建分布式系統中一些常見模式的工具（例如配置管理，服務發現，斷路器，智...
    卡卡羅2017閱讀 134,991評論 19贊 139
  • 前言 最近感觸頗深，原諒我在開頭寫心情日記。介意的跳過看正文。 市場 趨勢 近幾年，技術市場對新人越來越不友好，社...
    IT天宇閱讀 12,394評論 5贊 68
  • 什么是Spring Spring是一個開源的Java EE開發框架。Spring框架的核心功能可以應用在任何Jav...
    jemmm閱讀 16,562評論 1贊 133
  • Spring Boot 參考指南 介紹 轉載自:https://www.gitbook.com/book/qbgb...
    毛宇鵬閱讀 46,971評論 6贊 342
  • l姑娘今天離職了。一晃四年，認識她是在大學教學樓的連廊背單詞的日子。畢業后來到現在這家號稱全國前三的民企，從什么都...
    來自長江邊的貓閱讀 132評論 0贊 1