WhatSize for Mac是一款MacOS操作系统上好用的磁盘管理软件，WhatSize for Mac允许您快速查看和管理磁盘空间使用情况并加快您的Mac的应用程序，WhatSize mac版能够快速测量您的硬盘驱动器的大小，并允许您对结果进行排序，过滤和优化。
 
 
WhatSize Mac功能介绍
 
良好的结构化磁盘分析器，可以测量包含的文件和文件夹
 
WhatSize Mac自动检测可用卷和收藏夹文件夹并测量其内容以突出显示严重压力的存储空间。当然，WhatSize也是允许您手动将新文件夹添加到列表中。
 
另外，WhatSize包括一个重复的finder，一个delocalizer（找到所有的语言文件和allos你删除你不需要的ons）和一个更干净的工具（检测日志，下载，缓存，Nib，本地化和临时文件）。
 
为方便起见，WhatSize为您提供了以管理员身份删除文件和文件夹的选项使用sudo命令。但是，如果启用此功能，则必须非常小心，不要删除对操作系统至关重要的项目。
 
不复杂但非常有效的磁盘测量和清洁解决方案
 
WhatSize Mac破解版是一个很好的工具，在Mac上，如果你的存储空间不足，你不知道为什么。该应用程序测量磁盘内容，强调最大的磁盘内容，使您能够检测复制或不必要的文件，并提供简单的工具，以便在任何时间删除它们。要确保某些文件和文件夹保持不变，您可以选择创建和排除列表。最后，WhatSize使您能够将当前选择导出为CSV文件。
 
 
WhatSize for Mac功能特点
 
测量
 
WhatSize快速测量存储设备的大小，并允许您对结果进行排序，过滤和优化。文件和文件夹会自动按大小排序，以显示最大的大小。该应用程序使用最新的macOS技术来保持任何更改的最新状态，而无需重新扫描所有内容。
 
 
图表显示
 
通过交互式图表可视化磁盘使用情况。单击以向下钻取更多详细信息。
 
清洁工具
 
智能工具可帮助您找到浪费空间的对象，并且只需单击一下即可将其删除。让WhatSize清理日志文件，下载，缓存，临时文件和应用程序混乱情况，例如不需要您不会说的语言的不需要的翻译。回收空间并加快Mac的运行速度。
 
查找重复项
 
查找重复的文件并打扫房子！WhatSize允许您将它们移到回收站，立即将其删除，或将其替换为硬链接。按大小排序和过滤，以首先处理最大的文件或全部处理。
 

one epoch = one forward pass and one backward pass of all the training examples
 batch size = the number of training examples in one forward/backward pass. The higher the batch size, the more memory space you’ll need.
 number of iterations = number of passes, each pass using [batch size] number of examples. To be clear, one pass = one forward pass + one backward pass (we do not count the forward pass and backward pass as two different passes).
 Example: if you have 1000 training examples, and your batch size is 500, then it will take 2 iterations to complete 1 epoch.
 重点是:
 如果你有1000个训练集,batch_size=500,那么需要两次迭代才能完成一次epoch
 
 
In batch processing, the gradient is evaluated for several different input/output values, with each observation yielding a different vector. We then average together the gradient vectors over all observations in the batch and take a single step in the resulting direction.
 
The benefit of this is that the gradient estimate using a single point only may be very noisy. By averaging together the gradient over many samples we obtain a less noisy estimate.
 
I’ll also point out that having too large of a batch can also be a bad thing. Sometimes the noise in the gradient direction can kick you out of local minima and help you get to a better solution. This is problem specific, though, so when training a NN, you should experiment with many different batch sizes. This paper goes into further detail about this
 batch_size
 
The documentation for Keras about batch size can be found under the fit function in the Models (functional API) page
 
这段话的重点是:
 从反向传播的误差角度进行评估,如果batch_size很小的话,那么Loss的计算就很容易受到噪声的影响,因此需要手动设置.
 
 
batch_size: Integer or None. Number of samples per gradient update.
 If unspecified, batch_size will default to 32.
 
If you have a small dataset, it would be best to make the batch size equal to the size of the training data. First try with a small batch then increase to save time. As itdxer mentioned, there’s a tradeoff between accuracy and speed.
 重点是:
 在你的数据集很小的时候,最好和你的数据集设置的差不多大小.
 当你不指定的时候,batch_size默认是32位
 
转载自:
 https://stats.stackexchange.com/questions/153531/what-is-batch-size-in-neural-network
 https://stats.stackexchange.com/questions/303022/understanding-batch-size-in-neural-networks

# 0.学习目标
 
- 了解SpringBoot的作用
 - 掌握java配置的方式
 - 了解SpringBoot自动配置原理
 - 掌握SpringBoot的基本使用
 - 了解Thymeleaf的基本使用
 
# 1. 了解SpringBoot
 
在这一部分，我们主要了解以下3个问题：
 
- 什么是SpringBoot
 - 为什么要学习SpringBoot
 - SpringBoot的特点
 
## 1.1.什么是SpringBoot
 
SpringBoot是Spring项目中的一个子工程，与我们所熟知的Spring-framework 同属于spring的产品:
 
![1527681455097](assets/1527681455097.png)
 
我们可以看到下面的一段介绍：
 
> Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can "just run".
 >
 > We take an opinionated view of the Spring platform and third-party libraries so you can get started with minimum fuss. Most Spring Boot applications need very little Spring configuration.
 
翻译一下：
 
> Spring Boot你只需要“run”就可以非常轻易的构建独立的、生产级别的spring应用。
 >
 > 我们为spring平台和第三方依赖库提供了一种固定化的使用方式，使你能非常轻松的开始开发你的应用程序。大部分Spring Boot应用只需要很少的配置。
 
其实人们把Spring Boot称为搭建程序的`脚手架`。其最主要作用就是帮我们快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让我们关注于业务而非配置。
 
我们可以使用SpringBoot创建java应用，并使用java –jar 启动它，就能得到一个生产级别的web工程。
 
## 1.2.为什么要学习SpringBoot
 
java一直被人诟病的一点就是臃肿、麻烦。当我们还在辛苦的搭建项目时，可能Python程序员已经把功能写好了，究其原因主要是两点：
 
- 复杂的配置
 
  项目各种配置其实是开发时的损耗， 因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。
 
- 混乱的依赖管理
 
  项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这也是件棘手的问题。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。
 
而SpringBoot让这一切成为过去！
 
## 1.3.SpringBoot的特点
 
Spring Boot 主要特征是：
 
- 创建独立的spring应用程序
 - 直接内嵌tomcat、jetty和undertow（不需要打包成war包部署）
 - 提供了固定化的“starter”配置，以简化构建配置
 - 尽可能的自动配置spring和第三方库
 - 提供产品级的功能，如：安全指标、运行状况监测和外部化配置等
 - 绝对不会生成代码，并且不需要XML配置
 
总之，Spring Boot为所有 Spring 的开发者提供一个开箱即用的、非常快速的、广泛接受的入门体验
 
更多细节，大家可以到[官网](http://projects.spring.io/spring-boot/)查看。
 
# 2.快速入门
 
接下来，我们就来利用SpringBoot搭建一个web工程，体会一下SpringBoot的魅力所在！
 
环境要求：
 
![1527695636167](assets/1527695636167.png)
 
## 2.1.创建工程
 
我们先新建一个空的demo工程，如下：
 
![1527690475282](assets/1527690475282.png)
 
![1527690564245](assets/1527690564245.png)
 
创建以moduel：
 
![1527690810779](assets/1527690810779.png)
 
![1527694194289](assets/1527694194289.png)
 
填写坐标信息：
 
![1527694371964](assets/1527694371964.png)
 
目录结构：
 
![1527694504570](assets/1527694504570.png)
 
创建完成后的目录结构：
 
![1527694634778](assets/1527694634778.png)
 
## 2.2.引入依赖
 
看到这里很多同学会有疑惑，前面说传统开发的问题之一就是依赖管理混乱，怎么这里我们还需要管理依赖呢？难道SpringBoot不帮我们管理吗？
 
别着急，现在我们的项目与SpringBoot还没有什么关联。SpringBoot提供了一个名为spring-boot-starter-parent的工程，里面已经对各种常用依赖（并非全部）的版本进行了管理，我们的项目需要以这个项目为父工程，这样我们就不用操心依赖的版本问题了，需要什么依赖，直接引入坐标即可！
 
 ![1527751740943](assets/1527751740943.png)
 
```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
    <groupId>cn.itcast.springboot</groupId>
     <artifactId>itcast-springboot</artifactId>
     <version>1.0-SNAPSHOT</version>
 
    <!-- 所有的springboot的工程都以spring父工程为父工程 -->
     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>2.0.4.RELEASE</version>
     </parent>
 
    <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
     </dependencies>
 </project>
 ```
 
## 2.3.编写HelloController
 
 ![1540894662227](assets/1540894662227.png)
 
代码：
 
```java
 @RestController
 @EnableAutoConfiguration
 public class HelloController {
 
    @GetMapping("show")
     public String test(){
         return "hello Spring Boot!";
     }
 
    public static void main(String[] args) {
         SpringApplication.run(HelloController.class, args);
     }
 }
 ```
 
## 2.4.启动测试
 
![1527755353246](assets/1527755353246.png)
 
![1527755521637](assets/1527755521637.png)
 
![1527755975973](assets/1527755975973.png)
 
bingo！访问成功！
 
## 2.5.详解
 
入门工程中：pom.xml里引入了启动器的概念以@EnableAutoConfiguration注解。
 
### 2.5.1.启动器
 
为了让SpringBoot帮我们完成各种自动配置，我们必须引入SpringBoot提供的自动配置依赖，我们称为`启动器`。spring-boot-starter-parent工程将依赖关系声明为一个或者多个启动器，我们可以根据项目需求引入相应的启动器，因为我们是web项目，这里我们引入web启动器：
 
```xml
 <dependencies>
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
 </dependencies>
 ```
 
需要注意的是，我们并没有在这里指定版本信息。因为SpringBoot的父工程已经对版本进行了管理了。
 
这个时候，我们会发现项目中多出了大量的依赖：
 
 ![1540894098029](../../../../%E6%95%99%E5%AD%A6/leyou/day01-springboot/%E7%AC%94%E8%AE%B0/assets/1540894098029.png)
 
这些都是SpringBoot根据spring-boot-starter-web这个依赖自动引入的，而且所有的版本都已经管理好，不会出现冲突。
 
### 2.5.2.@EnableAutoConfiguration
 
关于这个注解，官网上有一段说明：
 
> Enable auto-configuration of the Spring Application Context, attempting to guess and configure beans that you are likely to need. Auto-configuration classes are usually applied based on your classpath and what beans you have defined.
 
简单翻译以下：
 
> 开启spring应用程序的自动配置，SpringBoot基于你所添加的依赖和你自己定义的bean，试图去猜测并配置你想要的配置。比如我们引入了`spring-boot-starter-web`，而这个启动器中帮我们添加了`tomcat`、`SpringMVC`的依赖。此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了！
 
总结，SpringBoot内部对大量的第三方库或Spring内部库进行了默认配置，这些配置是否生效，取决于我们是否引入了对应库所需的依赖，如果有那么默认配置就会生效。
 
所以，我们使用SpringBoot构建一个项目，只需要引入所需依赖，配置就可以交给SpringBoot处理了。
 
## 2.6.优化入门程序
 
现在工程中只有一个Controller，可以这么玩；那么如果有多个Controller，怎么办呢？
 
添加Hello2Controller：
 
 ![1527949030771](/assets/1527949030771.png)
 
代码：
 
```java
 @RestController
 public class Hello2Controller {
 
    @GetMapping("show2")
     public String test(){
         return "hello Spring Boot2!";
     }
 
}
 ```
 
启动重新启动，访问show2测试，失败：
 
![1528087951866](assets/1528087951866.png)
 
难道要在每一个Controller中都添加一个main方法和@EnableAutoConfiguration注解，这样启动一个springboot程序也太麻烦了。也无法同时启动多个Controller，因为每个main方法都监听8080端口。所以，一个springboot程序应该只有一个springboot的main方法。
 
所以，springboot程序引入了一个全局的引导类。
 
### 2.5.1.添加引导类
 
通常请求下，我们在一个springboot工程中都会在基包下创建一个引导类，一些springboot的全局注解（@EnableAutoConfiguration注解）以及springboot程序的入口main方法都放在该类中。
 
在springboot的程序的基包下（引导类和Controller包在同级目录下），创建TestApplication.class：
 
 ![1527760765673](assets/1527760765673.png)
 
内容如下：
 
```java
 @EnableAutoConfiguration
 public class TestApplication {
 
    public static void main(String[] args) {
         SpringApplication.run(TestApplication.class, args);
     }
 }
 ```
 
并修改HelloController，去掉main方法及@EnableAutoConfiguration：
 
```java
 @RestController
 public class HelloController {
 
    @GetMapping("show")
     public String test(){
         return "hello Spring Boot!";
     }
 }
 ```
 
启动引导类，访问show测试：
 
![1528088990216](assets/1528088990216.png)
 
发现所有的Controller都不能访问，为什么？
 
回想以前程序，我们在配置文件中添加了注解扫描，它能扫描指定包下的所有Controller，而现在并没有。怎么解决——@ComponentScan注解
 
### 2.5.2.@ComponentScan
 
spring框架除了提供配置方式的注解扫描`<context:component-scan />`，还提供了注解方式的注解扫描`@ComponentScan`。
 
在TestApplication.class中，使用@ComponentScan注解：
 
```java
 @EnableAutoConfiguration
 @ComponentScan
 public class TestApplication {
 
    public static void main(String[] args) {
         SpringApplication.run(TestApplication.class, args);
     }
 
}
 ```
 
重新启动，访问show或者show2：
 
![1528089792848](assets/1528089792848.png)
 
![1527772795552](assets/1527772795552.png)
 
我们跟进该注解的源码，并没有看到什么特殊的地方。我们查看注释：
 
![1527818066552](/assets/1527818066552.png)
 
大概的意思：
 
> 配置组件扫描的指令。提供了类似与`<context:component-scan>`标签的作用
 >
 > 通过basePackageClasses或者basePackages属性来指定要扫描的包。如果没有指定这些属性，那么将从声明这个注解的类所在的包开始，扫描包及子包
 
而我们的@ComponentScan注解声明的类就是main函数所在的启动类，因此扫描的包是该类所在包及其子包。**一般启动类会放在一个比较浅的包目录中。**
 
### 2.5.3.@SpringBootApplication
 
我们现在的引导类中使用了@EnableAutoConfiguration和@ComponentScan注解，有点麻烦。springboot提供了一种简便的玩法：@SpringBootApplication注解
 
使用@SpringBootApplication改造TestApplication：
 
```java
 @SpringBootApplication
 public class TestApplication {
 
    public static void main(String[] args) {
         SpringApplication.run(TestApplication.class, args);
     }
 
}
 ```
 
点击进入，查看源码：
 
![1528093556068](assets/1528093556068.png)
 
发现@SpringBootApplication其实是一个组合注解，这里重点的注解有3个：
 
- @SpringBootConfiguration
 - @EnableAutoConfiguration：开启自动配置
 - @ComponentScan：开启注解扫描
 
### 2.5.4.@SpringBootConfiguration
 
@SpringBootConfiguration注解的源码：
 
我们继续点击查看源码：
 
![1528095223949](assets/1528095223949.png)
 
通过这段我们可以看出，在这个注解上面，又有一个`@Configuration`注解。通过上面的注释阅读我们知道：这个注解的作用就是声明当前类是一个配置类，然后Spring会自动扫描到添加了`@Configuration`的类，并且读取其中的配置信息。而`@SpringBootConfiguration`是来声明当前类是SpringBoot应用的配置类，项目中只能有一个。所以一般我们无需自己添加。
 
# 3.默认配置原理
 
springboot的默认配置方式和我们之前玩的配置方式不太一样，没有任何的xml。那么如果自己要新增配置该怎么办？比如我们要配置一个数据库连接池，以前会这么玩：
 
```xml
 <!-- 配置连接池 -->
 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
       init-method="init" destroy-method="close">
     <property name="url" value="${jdbc.url}" />
     <property name="username" value="${jdbc.username}" />
     <property name="password" value="${jdbc.password}" />
 </bean>
 ```
 
现在该怎么做呢?
 
## 3.1.回顾历史
 
事实上，在Spring3.0开始，Spring官方就已经开始推荐使用java配置来代替传统的xml配置了，我们不妨来回顾一下Spring的历史：
 
- Spring1.0时代
 
  在此时因为jdk1.5刚刚出来，注解开发并未盛行，因此一切Spring配置都是xml格式，想象一下所有的bean都用xml配置，细思极恐啊，心疼那个时候的程序员2秒
 
- Spring2.0时代
 
  Spring引入了注解开发，但是因为并不完善，因此并未完全替代xml，此时的程序员往往是把xml与注解进行结合，貌似我们之前都是这种方式。
 
- Spring3.0及以后
 
  3.0以后Spring的注解已经非常完善了，因此Spring推荐大家使用完全的java配置来代替以前的xml，不过似乎在国内并未推广盛行。然后当SpringBoot来临，人们才慢慢认识到java配置的优雅。
 
有句古话说的好：拥抱变化，拥抱未来。所以我们也应该顺应时代潮流，做时尚的弄潮儿，一起来学习下java配置的玩法。
 
## 3.2.尝试java配置
 
java配置主要靠java类和一些注解来达到和xml配置一样的效果，比较常用的注解有：
 
- `@Configuration`：声明一个类作为配置类，代替xml文件
 - `@Bean`：声明在方法上，将方法的返回值加入Bean容器，代替`<bean>`标签
 - `@Value`：属性注入 
 - `@PropertySource`：指定外部属性文件。
 
我们接下来用java配置来尝试实现连接池配置
 
 ![1540895699735](assets/1540895699735.png)
 
### 3.2.1.引入依赖
 
首先在pom.xml中，引入Druid连接池依赖：
 
```xml
 <dependency>
     <groupId>com.github.drtrang</groupId>
     <artifactId>druid-spring-boot2-starter</artifactId>
     <version>1.1.10</version>
 </dependency>
 ```
 
### 3.2.2.添加jdbc.properties
 
```properties
 jdbc.driverClassName=com.mysql.jdbc.Driver
 jdbc.url=jdbc:mysql://127.0.0.1:3306/leyou
 jdbc.username=root
 jdbc.password=123
 ```
 
### 3.2.3.配置数据源
 
创建JdbcConfiguration类：
 
```java
 @Configuration
 @PropertySource("classpath:jdbc.properties")
 public class JdbcConfiguration {
 
    @Value("${jdbc.url}")
     String url;
     @Value("${jdbc.driverClassName}")
     String driverClassName;
     @Value("${jdbc.username}")
     String username;
     @Value("${jdbc.password}")
     String password;
 
    @Bean
     public DataSource dataSource() {
         DruidDataSource dataSource = new DruidDataSource();
         dataSource.setUrl(url);
         dataSource.setDriverClassName(driverClassName);
         dataSource.setUsername(username );
         dataSource.setPassword(password);
         return dataSource;
     }
 }
 ```
 
解读：
 
- `@Configuration`：声明`JdbcConfiguration`是一个配置类。
 - `@PropertySource`：指定属性文件的路径是:`classpath:jdbc.properties`
 - 通过`@Value`为属性注入值。
 - 通过@Bean将 `dataSource()`方法声明为一个注册Bean的方法，Spring会自动调用该方法，将方法的返回值加入Spring容器中。相当于以前的bean标签
 
然后就可以在任意位置通过`@Autowired`注入DataSource了！
 
### 3.2.4.测试
 
我们在`HelloController`中测试：
 
```java
 @RestController
 public class HelloController {
 
    @Autowired
     private DataSource dataSource;
 
    @GetMapping("show")
     public String test(){
         return "hello Spring Boot!";
     }
 
}
 ```
 
在test方法中打一个断点，然后Debug运行并查看：
 
![1528098961065](assets/1528098961065.png)
 
属性注入成功了！
 
## 3.3.SpringBoot的属性注入
 
在上面的案例中，我们实验了java配置方式。不过属性注入使用的是@Value注解。这种方式虽然可行，但是不够强大，因为它只能注入基本类型值。
 
在SpringBoot中，提供了一种新的属性注入方式，支持各种java基本数据类型及复杂类型的注入。
 
1）新建`JdbcProperties`，用来进行属性注入：
 
 ![1540895952978](assets/1540895952978.png)
 
代码：
 
```java
 @ConfigurationProperties(prefix = "jdbc")
 public class JdbcProperties {
     private String url;
     private String driverClassName;
     private String username;
     private String password;
     // ... 略
     // getters 和 setters
 }
 
```
 
- 在类上通过@ConfigurationProperties注解声明当前类为属性读取类
 
- `prefix="jdbc"`读取属性文件中，前缀为jdbc的值。
 
- 在类上定义各个属性，名称必须与属性文件中`jdbc.`后面部分一致，并且必须具有getter和setter方法
 
- 需要注意的是，这里我们并没有指定属性文件的地址，SpringBoot默认会读取文件名为application.properties的资源文件，所以我们**把jdbc.properties名称改为application.properties**
 

 2）在JdbcConfiguration中使用这个属性：
 
- 通过`@EnableConfigurationProperties(JdbcProperties.class)`来声明要使用`JdbcProperties`这个类的对象
 
- 然后你可以通过以下方式在JdbcConfiguration类中注入JdbcProperties：
 
  1. @Autowired注入
 
  ```java
   @Configuration
   @EnableConfigurationProperties(JdbcProperties.class)
   public class JdbcConfiguration {
 
      @Autowired
       private JdbcProperties jdbcProperties;
 
      @Bean
       public DataSource dataSource() {
           DruidDataSource dataSource = new DruidDataSource();
           dataSource.setUrl(jdbcProperties.getUrl());
           dataSource.setDriverClassName(jdbcProperties.getDriverClassName());
           dataSource.setUsername(jdbcProperties.getUsername());
           dataSource.setPassword(jdbcProperties.getPassword());
           return dataSource;
       }
 
  }
   ```
 
  1. 构造函数注入
 
  ```java
   @Configuration
   @EnableConfigurationProperties(JdbcProperties.class)
   public class JdbcConfiguration {
 
      private JdbcProperties jdbcProperties;
 
      public JdbcConfiguration(JdbcProperties jdbcProperties){
           this.jdbcProperties = jdbcProperties;
       }
 
      @Bean
       public DataSource dataSource() {
           // 略
       }
 
  }
   ```
 
  1. @Bean方法的参数注入
 
  ```java
   @Configuration
   @EnableConfigurationProperties(JdbcProperties.class)
   public class JdbcConfiguration {
 
      @Bean
       public DataSource dataSource(JdbcProperties jdbcProperties) {
           // ...
       }
   }
   ```
 
本例中，我们采用第三种方式。
 
3）测试结果：
 
![1527783292437](assets/1527783292437.png)
 
大家会觉得这种方式似乎更麻烦了，事实上这种方式有更强大的功能，也是SpringBoot推荐的注入方式。两者对比关系：
 
![1528103259908](assets/1528103259908.png)
 
优势：
 
- Relaxed binding：松散绑定
 
  - 不严格要求属性文件中的属性名与成员变量名一致。支持驼峰，中划线，下划线等等转换，甚至支持对象引导。比如：user.friend.name：代表的是user对象中的friend属性中的name属性，显然friend也是对象。@value注解就难以完成这样的注入方式。
   - meta-data support：元数据支持，帮助IDE生成属性提示（写开源框架会用到）。
 

 ## 3.4.更优雅的注入
 
事实上，如果一段属性只有一个Bean需要使用，我们无需将其注入到一个类（JdbcProperties）中。而是直接在需要的地方声明即可：
 
```java
 @Configuration
 public class JdbcConfiguration {
     
     @Bean
     // 声明要注入的属性前缀，SpringBoot会自动把相关属性通过set方法注入到DataSource中
     @ConfigurationProperties(prefix = "jdbc")
     public DataSource dataSource() {
         DruidDataSource dataSource = new DruidDataSource();
         return dataSource;
     }
 }
 ```
 
我们直接把`@ConfigurationProperties(prefix = "jdbc")`声明在需要使用的`@Bean`的方法上，然后SpringBoot就会自动调用这个Bean（此处是DataSource）的set方法，然后完成注入。使用的前提是：**该类必须有对应属性的set方法！**
 
我们将jdbc的url改成：/heima，再次测试：
 
![1528103369170](assets/1528103369170.png)
 
## 3.5.SpringBoot中的默认配置
 
通过刚才的学习，我们知道@EnableAutoConfiguration会开启SpringBoot的自动配置，并且根据你引入的依赖来生效对应的默认配置。那么问题来了：
 
- 这些默认配置是怎么配置的，在哪里配置的呢？
 - 为何依赖引入就会触发配置呢？
 - 这些默认配置的属性来自哪里呢？
 
其实在我们的项目中，已经引入了一个依赖：spring-boot-autoconfigure，其中定义了大量自动配置类：
 
 ![1527931944702](assets/1527931944702.png)
 
还有：
 
 ![1527931968031](assets/1527931968031.png)
 
非常多，几乎涵盖了现在主流的开源框架，例如：
 
- redis
 - jms
 - amqp
 - jdbc
 - jackson
 - mongodb
 - jpa
 - solr
 - elasticsearch
 
... 等等
 
我们来看一个我们熟悉的，例如SpringMVC，查看mvc 的自动配置类：
 
  ![1527933162533](assets/1527933162533.png)
 
打开WebMvcAutoConfiguration：
 
![1527933633048](assets/1527933633048.png)
 
我们看到这个类上的4个注解：
 
- `@Configuration`：声明这个类是一个配置类
 
- `@ConditionalOnWebApplication(type = Type.SERVLET)`
 
  ConditionalOn，翻译就是在某个条件下，此处就是满足项目的类是是Type.SERVLET类型，也就是一个普通web工程，显然我们就是
 
- `@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })`
 
  这里的条件是OnClass，也就是满足以下类存在：Servlet、DispatcherServlet、WebMvcConfigurer，其中Servlet只要引入了tomcat依赖自然会有，后两个需要引入SpringMVC才会有。这里就是判断你是否引入了相关依赖，引入依赖后该条件成立，当前类的配置才会生效！
 
- `@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)`
 
  这个条件与上面不同，OnMissingBean，是说环境中没有指定的Bean这个才生效。其实这就是自定义配置的入口，也就是说，如果我们自己配置了一个WebMVCConfigurationSupport的类，那么这个默认配置就会失效！
 
接着，我们查看该类中定义了什么：
 
视图解析器：
 
![1527933646831](assets/1527933646831.png)
 
处理器适配器（HandlerAdapter）：
 
![1527933659948](assets/1527933659948.png)
 
还有很多，这里就不一一截图了。
 
另外，这些默认配置的属性来自哪里呢？
 
![1528096733440](assets/1528096733440.png)
 
我们看到，这里通过@EnableAutoConfiguration注解引入了两个属性：WebMvcProperties和ResourceProperties。
 
我们查看这两个属性类：
 
![1528096851318](assets/1528096851318.png)
 
找到了内部资源视图解析器的prefix和suffix属性。
 
ResourceProperties中主要定义了静态资源（.js,.html,.css等)的路径：
 
![1528096892588](assets/1528096892588.png)
 
如果我们要覆盖这些默认属性，只需要在application.properties中定义与其前缀prefix和字段名一致的属性即可。
 
## 3.6.总结
 
SpringBoot为我们提供了默认配置，而默认配置生效的条件一般有两个：
 
- 你引入了相关依赖
 - 你自己没有配置
 
1）启动器
 
之所以，我们如果不想配置，只需要引入依赖即可，而依赖版本我们也不用操心，因为只要引入了SpringBoot提供的stater（启动器），就会自动管理依赖及版本了。
 
因此，玩SpringBoot的第一件事情，就是找启动器，SpringBoot提供了大量的默认启动器，参考课前资料中提供的《SpringBoot启动器.txt》
 
2）全局配置
 
另外，SpringBoot的默认配置，都会读取默认属性，而这些属性可以通过自定义`application.properties`文件来进行覆盖。这样虽然使用的还是默认配置，但是配置中的值改成了我们自定义的。
 
因此，玩SpringBoot的第二件事情，就是通过`application.properties`来覆盖默认属性值，形成自定义配置。我们需要知道SpringBoot的默认属性key，非常多，参考课前资料提供的：《SpringBoot全局属性.md》
 
# 4.SpringBoot实战
 
接下来，我们来看看如何用SpringBoot来玩转以前的SSM,我们沿用之前讲解SSM用到的数据库tb_user和实体类User
 
## 4.1.创建工程
 
![1540896476056](assets/1540896476056.png)
 
![1540896950344](assets/1540896950344.png)
 
![1540896657008](assets/1540896657008.png)
 
## 4.2.编写基本代码
 
 ![1540898508682](assets/1540898508682.png)
 
pom.xml:
 
```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>cn.itcast.user</groupId>
     <artifactId>itcast-user</artifactId>
     <version>1.0-SNAPSHOT</version>
 
    <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>2.0.4.RELEASE</version>
     </parent>
 
    <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
     </dependencies>
 
</project>
 ```
 
参照上边的项目，编写引导类：
 
```java
 @SpringBootApplication
 public class UserApplication {
 
    public static void main(String[] args) {
         SpringApplication.run(UserApplication.class);
     }
 }
 ```
 
编写UserController：
 
```java
 @RestController
 @RequestMapping("user")
 public class UserController {
 
    @GetMapping("hello")
     public String test(){
         return "hello ssm";
     }
 }
 ```
 
## 4.3.整合SpringMVC
 
虽然默认配置已经可以使用SpringMVC了，不过我们有时候需要进行自定义配置。
 
### 4.3.1.修改端口
 
添加全局配置文件：application.properties
 
 ![1540898582724](assets/1540898582724.png)
 
端口通过以下方式配置
 
 ![1540898053088](assets/1540898053088.png)
 
```properties
 # 映射端口
 server.port=80
 ```
 
重启服务后测试：
 
![1528116232569](assets/1528116232569.png)
 
 ![1528116322747](assets/1528116322747.png)
 
### 4.3.2.访问静态资源
 
现在，我们的项目是一个jar工程，那么就没有webapp，我们的静态资源该放哪里呢？
 
回顾我们上面看的源码，有一个叫做ResourceProperties的类，里面就定义了静态资源的默认查找路径： ![1528096892588](assets/1528096892588.png)
 
默认的静态资源路径为：
 
- classpath:/META-INF/resources/
 - classpath:/resources/
 - classpath:/static/
 - classpath:/public/
 
只要静态资源放在这些目录中任何一个，SpringMVC都会帮我们处理。
 
我们习惯会把静态资源放在`classpath:/static/`目录下。我们创建目录，并且添加一些静态资源：
 
 ![1540898730442](assets/1540898730442.png)
 
重启项目后测试：
 
![1540898831238](assets/1540898831238.png)
 
### 4.3.3.添加拦截器
 
拦截器也是我们经常需要使用的，在SpringBoot中该如何配置呢？
 
拦截器不是一个普通属性，而是一个类，所以就要用到java配置方式了。在SpringBoot官方文档中有这么一段说明：
 
> If you want to keep Spring Boot MVC features and you want to add additional [MVC configuration](https://docs.spring.io/spring/docs/5.0.5.RELEASE/spring-framework-reference/web.html#mvc) (interceptors, formatters, view controllers, and other features), you can add your own `@Configuration` class of type `WebMvcConfigurer` but **without** `@EnableWebMvc`. If you wish to provide custom instances of `RequestMappingHandlerMapping`, `RequestMappingHandlerAdapter`, or `ExceptionHandlerExceptionResolver`, you can declare a `WebMvcRegistrationsAdapter` instance to provide such components.
 >
 > If you want to take complete control of Spring MVC, you can add your own `@Configuration` annotated with `@EnableWebMvc`.
 
翻译：
 
> 如果你想要保持Spring Boot 的一些默认MVC特征，同时又想自定义一些MVC配置（包括：拦截器，格式化器, 视图控制器、消息转换器 等等），你应该让一个类实现`WebMvcConfigurer`，并且添加`@Configuration`注解，但是**千万不要**加`@EnableWebMvc`注解。如果你想要自定义`HandlerMapping`、`HandlerAdapter`、`ExceptionResolver`等组件，你可以创建一个`WebMvcRegistrationsAdapter`实例 来提供以上组件。
 >
 > 如果你想要完全自定义SpringMVC，不保留SpringBoot提供的一切特征，你可以自己定义类并且添加`@Configuration`注解和`@EnableWebMvc`注解
 
总结：通过实现`WebMvcConfigurer`并添加`@Configuration`注解来实现自定义部分SpringMvc配置。
 
实现如下：
 
 ![1540899012303](assets/1540899012303.png)
 
首先我们定义一个拦截器：
 
```java
 @Component
 public class MyInterceptor implements HandlerInterceptor {
     @Override
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
         System.out.println("preHandle method is running!");
         return true;
     }
 
    @Override
     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
         System.out.println("postHandle method is running!");
     }
 
    @Override
     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
         System.out.println("afterCompletion method is running!");
     }
 }
 ```
 
然后定义配置类，注册拦截器：
 
```java
 @Configuration
 public class MvcConfiguration implements WebMvcConfigurer {
 
    @Autowired
     private HandlerInterceptor myInterceptor;
 
    /**
      * 重写接口中的addInterceptors方法，添加自定义拦截器
      * @param registry
      */
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(myInterceptor).addPathPatterns("/**");
     }
 }
 ```
 
接下来运行并查看日志：
 
```verilog
 preHandle method is running!
 postHandle method is running!
 afterCompletion method is running!
 ```
 
你会发现日志中只有这些打印信息，springMVC的日志信息都没有，因为springMVC记录的log级别是debug，springboot默认是显示info以上，我们需要进行配置。
 
SpringBoot通过`logging.level.*=debug`来配置日志级别，*填写包名
 
```properties
 # 设置org.springframework包的日志级别为debug
 logging.level.org.springframework=debug
 ```
 
再次运行查看：
 
![1540899090277](assets/1540899090277.png)
 
## 4.4.整合连接池
 
jdbc连接池是spring配置中的重要一环，在SpringBoot中该如何处理呢？
 
答案是不需要处理，我们只要找到SpringBoot提供的启动器即可：
 
![1528126755717](assets/1528126755717.png)
 
在pom.xml中引入jdbc的启动器：
 
```xml
 <!--jdbc的启动器，默认使用HikariCP连接池-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-jdbc</artifactId>
 </dependency>
 <!--不要忘记数据库驱动，因为springboot不知道我们使用的什么数据库，这里选择mysql-->
 <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
 </dependency>
 ```
 
SpringBoot已经自动帮我们引入了一个连接池：
 
 ![1528126862203](assets/1528126862203.png)
 
HikariCP应该是目前速度最快的连接池了，我们看看它与c3p0的对比：
 
 ![1525516441005](assets/1525516441005.png)
 
因此，我们只需要指定连接池参数即可：
 
```properties
 # 连接四大参数
 spring.datasource.url=jdbc:mysql://localhost:3306/heima
 spring.datasource.username=root
 spring.datasource.password=root
 # 可省略，SpringBoot自动推断
 spring.datasource.driverClassName=com.mysql.jdbc.Driver
 
spring.datasource.hikari.idle-timeout=60000
 spring.datasource.hikari.maximum-pool-size=30
 spring.datasource.hikari.minimum-idle=10
 ```
 
当然，如果你更喜欢Druid连接池，也可以使用Druid官方提供的启动器：
 
```xml
 <!-- Druid连接池 -->
 <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>druid-spring-boot-starter</artifactId>
     <version>1.1.6</version>
 </dependency>
 ```
 
而连接信息的配置与上面是类似的，只不过在连接池特有属性上，方式略有不同：
 
```properties
 #初始化连接数
 spring.datasource.druid.initial-size=1
 #最小空闲连接
 spring.datasource.druid.min-idle=1
 #最大活动连接
 spring.datasource.druid.max-active=20
 #获取连接时测试是否可用
 spring.datasource.druid.test-on-borrow=true
 #监控页面启动
 spring.datasource.druid.stat-view-servlet.allow=true
 ```
 
## 4.5.整合mybatis
 
### 4.5.1.mybatis
 
SpringBoot官方并没有提供Mybatis的启动器，不过Mybatis[官方](https://github.com/mybatis/spring-boot-starter)自己实现了：
 
```xml
 <!--mybatis -->
 <dependency>
     <groupId>org.mybatis.spring.boot</groupId>
     <artifactId>mybatis-spring-boot-starter</artifactId>
     <version>1.3.2</version>
 </dependency>
 ```
 
配置，基本没有需要配置的：
 
```properties
 # mybatis 别名扫描
 mybatis.type-aliases-package=cn.itcast.pojo
 # mapper.xml文件位置,如果没有映射文件，请注释掉
 mybatis.mapper-locations=classpath:mappers/*.xml
 ```
 
需要注意，这里没有配置mapper接口扫描包，因此我们需要给每一个Mapper接口添加`@Mapper`注解，才能被识别。
 
 ![1528128785010](assets/1528128785010.png)
 
```java
 @Mapper
 public interface UserMapper {
 }
 ```
 
user对象参照课前资料，需要通用mapper的注解：
 
![1540899330478](assets/1540899330478.png)
 
接下来，就去集成通用mapper。
 
### 4.5.2.通用mapper
 
通用Mapper的作者也为自己的插件编写了启动器，我们直接引入即可：
 
```xml
 <!-- 通用mapper -->
 <dependency>
     <groupId>tk.mybatis</groupId>
     <artifactId>mapper-spring-boot-starter</artifactId>
     <version>2.0.2</version>
 </dependency>
 ```
 
不需要做任何配置就可以使用了。
 
```java
 @Mapper
 public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User>{
 }
 ```
 
## 4.6.整合事务
 
其实，我们引入jdbc或者web的启动器，就已经引入事务相关的依赖及默认配置了
 
 ![1528128711716](assets/1528128711716.png)
 
至于事务，SpringBoot中通过注解来控制。就是我们熟知的`@Transactional`
 
```java
 @Service
 public class UserService {
 
    @Autowired
     private UserMapper userMapper;
 
    public User queryById(Long id){
         return this.userMapper.selectByPrimaryKey(id);
     }
 
    @Transactional
     public void deleteById(Long id){
         this.userMapper.deleteByPrimaryKey(id);
     }
 }
 ```
 
## 4.7.启动测试
 
在UserController中添加测试方法，内容：
 
```java
 @RestController
 @RequestMapping("user")
 public class UserController {
 
    @Autowired
     private UserService userService;
 
    @GetMapping("{id}")
     public User queryUserById(@PathVariable("id")Long id){
         return this.userService.queryById(id);
     }
 
    @GetMapping("hello")
     public String test(){
         return "hello ssm";
     }
 }
 ```
 
我们启动项目，查看：
 
![1540900351215](assets/1540900351215.png)
 
## 4.8.完整项目结构
 
 ![1540900302611](assets/1540900302611.png)
 
完整的pom.xml：
 
```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>cn.itcast.user</groupId>
     <artifactId>itcast-user</artifactId>
     <version>1.0-SNAPSHOT</version>
 
    <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>2.0.4.RELEASE</version>
     </parent>
 
    <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
         <!--jdbc的启动器，默认使用HikariCP连接池-->
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-jdbc</artifactId>
         </dependency>
         <!--不要忘记数据库驱动，因为springboot不知道我们使用的什么数据库，这里选择mysql-->
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
         </dependency>
 
        <!--mybatis -->
         <dependency>
             <groupId>org.mybatis.spring.boot</groupId>
             <artifactId>mybatis-spring-boot-starter</artifactId>
             <version>1.3.2</version>
         </dependency>
 
        <!-- 通用mapper -->
         <dependency>
             <groupId>tk.mybatis</groupId>
             <artifactId>mapper-spring-boot-starter</artifactId>
             <version>2.0.2</version>
         </dependency>
     </dependencies>
 
</project>
 ```
 
完整的application.properties：
 
```properties
 server.port=80
 
logging.level.org.springframework=debug
 
spring.datasource.url=jdbc:mysql://localhost:3306/heima
 spring.datasource.username=root
 spring.datasource.password=root
 
# mybatis 别名扫描
 mybatis.type-aliases-package=cn.itcast.pojo
 # mapper.xml文件位置,如果没有映射文件，请注释掉
 # mybatis.mapper-locations=classpath:mappers/*.xml
 ```
 
# 5.Thymeleaf快速入门
 
SpringBoot并不推荐使用jsp，但是支持一些模板引擎技术：
 
![1525517263421](assets/1525517263421.png)
 
以前大家用的比较多的是Freemarker，但是我们今天的主角是Thymeleaf！
 
## 5.1.为什么是Thymeleaf？
 
简单说， Thymeleaf 是一个跟 Velocity、FreeMarker 类似的模板引擎，它可以完全替代 JSP 。相较于其他的模板引擎，它有如下四个极吸引人的特点：
 
- 动静结合：Thymeleaf 在有网络和无网络的环境下皆可运行，即它可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果。这是由于它支持 html 原型，然后在 html 标签里增加额外的属性来达到模板+数据的展示方式。浏览器解释 html 时会忽略未定义的标签属性，所以 thymeleaf 的模板可以静态地运行；当有数据返回到页面时，Thymeleaf 标签会动态地替换掉静态内容，使页面动态显示。
 - 开箱即用：它提供标准和spring标准两种方言，可以直接套用模板实现JSTL、 OGNL表达式效果，避免每天套模板、改jstl、改标签的困扰。同时开发人员也可以扩展和创建自定义的方言。
 - 多方言支持：Thymeleaf 提供spring标准方言和一个与 SpringMVC 完美集成的可选模块，可以快速的实现表单绑定、属性编辑器、国际化等功能。
 - 与SpringBoot完美整合，SpringBoot提供了Thymeleaf的默认配置，并且为Thymeleaf设置了视图解析器，我们可以像以前操作jsp一样来操作Thymeleaf。代码几乎没有任何区别，就是在模板语法上有区别。
 
接下来，我们就通过入门案例来体会Thymeleaf的魅力：
 
## 5.2.提供数据
 
编写一个controller方法，返回一些用户数据，放入模型中，将来在页面渲染
 
```java
 @GetMapping("/all")
 public String all(ModelMap model) {
     // 查询用户
     List<User> users = this.userService.queryAll();
     // 放入模型
     model.addAttribute("users", users);
     // 返回模板名称（就是classpath:/templates/目录下的html文件名）
     return "users";
 }
 ```
 
## 5.3.引入启动器
 
直接引入启动器：
 
```xml
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-thymeleaf</artifactId>
 </dependency>
 ```
 
SpringBoot会自动为Thymeleaf注册一个视图解析器：
 
 ![1528133744136](assets/1528133744136.png)
 
与解析JSP的InternalViewResolver类似，Thymeleaf也会根据前缀和后缀来确定模板文件的位置：
 
![1528133816179](assets/1528133816179.png)
 
- 默认前缀：`classpath:/templates/`
 - 默认后缀：`.html`
 
所以如果我们返回视图：`users`，会指向到 `classpath:/templates/users.html`
 
一般我们无需进行修改，默认即可。
 
## 5.4.静态页面
 
根据上面的文档介绍，模板默认放在classpath下的templates文件夹，我们新建一个html文件放入其中：
 
 ![1528134057401](assets/1528134057401.png)
 
编写html模板，渲染模型中的数据：
 
注意，把html 的名称空间，改成：`xmlns:th="http://www.thymeleaf.org"` 会有语法提示
 
```html
 <!DOCTYPE html>
 <html xmlns:th="http://www.thymeleaf.org">
 <head>
     <meta charset="UTF-8">
     <title>首页</title>
     <style type="text/css">
         table {border-collapse: collapse; font-size: 14px; width: 80%; margin: auto}
         table, th, td {border: 1px solid darkslategray;padding: 10px}
     </style>
 </head>
 <body>
 <div style="text-align: center">
     <span style="color: darkslategray; font-size: 30px">欢迎光临！</span>
     <hr/>
     <table class="list">
         <tr>
             <th>id</th>
             <th>姓名</th>
             <th>用户名</th>
             <th>年龄</th>
             <th>性别</th>
             <th>生日</th>
         </tr>
         <tr th:each="user : ${users}">
             <td th:text="${user.id}">1</td>
             <td th:text="${user.name}">张三</td>
             <td th:text="${user.userName}">zhangsan</td>
             <td th:text="${user.age}">20</td>
             <td th:text="${user.sex}">男</td>
             <td th:text="${user.birthday}">1980-02-30</td>
         </tr>
     </table>
 </div>
 </body>
 </html>

大学英语综合教程三 Unit 3 课文内容英译中 中英翻译
 
 
 
 
 
  大家好，我叫亓官劼（qí guān jié ），在CSDN中记录学习的点滴历程，时光荏苒，未来可期，加油~博客地址为：亓官劼的博客
 
 
 
  
本文原创为亓官劼，请大家支持原创，部分平台一直在盗取博主的文章！！！
 
 
 
 
博主目前仅在CSDN中写博客，唯一博客更新的地址为：亓官劼的博客
 
 
 
 
文本为博主整理翻译所得，送给有需要的小伙伴，还有综合教程一到4的课文文本翻译，后续陆续整理更新，都是之前学习时使用的一些资料，最近在整理电脑时发现的。
 
 
如果有需要可以收藏，全部更新完之后，会在本文内加入各个单元翻译的链接
 
 
大学英语 综合教程 一到四 课文文章翻译 英译中 所有文章的目录导航为：大学英语 综合教程 一到四 课文文章翻译 英译中 目录导航  
 
 
导航的博客地址为：https://blog.csdn.net/qq_43422111/article/details/105754423 有需要有去查看
 
 
 
Book III Unit 3 The Land of the Lock
 
锁之国
 
Bob Greene 
 
 
 
1     In the house where I grew up, it was our custom to leave the front door on the latch at night. I don't know if that was a local term or if it is universal; "on the latch" meant the door was closed but not locked. None of us carried keys; the last one in for the evening would close up, and that was it.
 
      小时候在家里，我们的前门总是夜不落锁。我不知道这是当地的一种说法还是大家都这么说；"不落锁"的意思是掩上门，但不锁住。我们谁都不带钥匙；晚上最后一个回家的人把门关上，这就行了。
 
2    Those days are over. In rural areas as well as in cities, doors do not stay unlocked, even for part of an evening.
 
      那样的日子已经一去不复返了。在乡下，在城里，门不再关着不锁上，哪怕是傍晚一段时间也不例外。
 
3    Suburbs and country areas are, in many ways, even more vulnerable than well-patroled urban streets. Statistics show the crime rate rising more dramatically in those allegedly tranquil areas than in cities. At any rate, the era of leaving the front door on the latch is over.
 
      在许多方面，郊区和农村甚至比巡查严密的城市街道更易受到攻击。统计显示，那些据称是安宁的地区的犯罪率上升得比城镇更为显著。不管怎么说，前门虚掩不落锁的时代是一去不复返了。
 
4    It has been replaced by dead-bolt locks, security chains, electronic alarm systems and trip wires hooked up to a police station or private guard firm. Many suburban families have sliding glass doors on their patios, with steel bars elegantly built in so no one can pry the doors open. 
 
取而代之的是防盗锁、防护链、电子报警系统，以及连接警署或私人保安公司的报警装置。郊区的许多人家在露台上安装了玻璃滑门，内侧有装得很讲究的钢条，这样就没人能把门撬开。
 
5    It is not uncommon, in the most pleasant of homes, to see pasted on the windows small notices announcing that the premises are under surveillance by this security force or that guard company.      
 
在最温馨的居家，也常常看得到窗上贴着小小的告示，称本宅由某家安全机构或某个保安公司负责监管。
 
6    The lock is the new symbol of America. Indeed, a recent public-service advertisement by a large insurance company featured not charts showing how much at risk we are, but a picture of a child's bicycle with the now-usual padlock attached to it. 
 
锁成了美国的新的象征。的确，一家大保险公司最近的一则公益广告没有用图表表明我们所处的危险有多大，而是用了一幅童车的图片，车身上悬着如今无所不在的挂锁。
 
7    The ad pointed out that, yes, it is the insurance companies that pay for stolen goods, but who is going to pay for what the new atmosphere of distrust and fear is doing to our way of life? Who is going to make the psychic payment for the transformation of America from the Land of the Free to the Land of the Lock? 
 
      广告指出，没错，确是保险公司理赔失窃物品，但谁来赔偿互不信任、担心害怕这种新氛围对我们的生活方式所造成的影响呢？谁来对美国从自由之国到锁之国这一蜕变作出精神赔偿呢？
 
8    For that is what has happened. We have become so used to defending ourselves against the new atmosphere of American life, so used to putting up barriers, that we have not had time to think about what it may mean. 
 
      因为那就是现状。我们已经变得如此习惯于保护自己不受美国生活新氛围的影响，如此习惯于设置障碍，因而无暇考虑这一切意味着什么。
 
9    For some reason we are satisfied when we think we are well-protected; it does not occur to us to ask ourselves: Why has this happened? Why are we having to barricade ourselves against our neighbors and fellow citizens, and when, exactly, did this start to take over our lives?
 
      出于某种原因，当我们觉得防范周密时就感到心满意足；我们没有问过自己：为什么会出现这种情况？为什么非得把自己与邻居和同住一城的居民相隔绝，这一切究竟是从什么时候开始主宰我们生活的？
 
10    And it has taken over. If you work for a medium- to large-size company, chances are that you don't just wander in and out of work. You probably carry some kind of access card, electronic or otherwise, that allows you in and out of your place of work. Maybe the security guard at the front desk knows your face and will wave you in most days, but the fact remains that the business you work for feels threatened enough to keep outsiders away via these "keys."
 
      这一切确是主宰了我们的生活。如果你在一家大中型公司上班，你上下班很可能不好随意进出。你可能随身带着某种出入卡，电子的或别的什么的，因为这卡能让你进出工作场所。也许前台的保安认识你这张脸，平日一挥手让你进去，但事实明摆着，你所任职的公司深感面临威胁，因此要借助这些“钥匙”不让外人靠近。
 
11    It wasn't always like this. Even a decade ago, most private businesses had a policy of free access. It simply didn't occur to managers that the proper thing to do was to distrust people.
 
      这一现象并非向来有之。即使在十年前，大多数私营公司仍采取自由出入的做法。那时管理人员根本没想到过恰当的手段是不信任他人。
 
12    Look at the airports. Parents used to take children out to departure gates to watch planes land and take off. That's all gone. Airports are no longer a place of education and fun; they are the most sophisticated of security sites.
 
      且看各地机场。过去家长常常带孩子去登机口看飞机起飞降落。这种事再也没有了。机场不再是一个有趣的学习场所；它们成了拥有最精密的安全检查系统的场所。
 
13    With electronic X-ray equipment, we seem finally to have figured out a way to hold the terrorists, real and imagined, at bay; it was such a relief to solve this problem that we did not think much about what such a state of affairs says about the quality of our lives. We now pass through these electronic friskers without so much as a sideways glance; the machines, and what they stand for, have won.
 
      凭借着电子透视装置，我们似乎终于想出妙计让恐怖分子无法近身，无论是真的恐怖分子还是凭空臆想的。能解决这一问题真是如释重负，于是我们不去多想这种状况对我们的生活质量意味着什么。如今我们走过这些电子搜查器时已经看都不看一眼了，这些装置，还有它们所代表的一切已经获胜。
 
14    Our neighborhoods are bathed in high-intensity light; we do not want to afford ourselves even so much a luxury as a shadow.
 
      我们的居住区处在强光源的照射下；我们连哪怕像阴影这样小小的享受也不想给自己。
 
15    Businessmen, in increasing numbers, are purchasing new machines that hook up to the telephone and analyze a caller's voice. The machines are supposed to tell the businessman, with a small margin of error, whether his friend or client is telling lies.
 
      越来越多的商人正购置连接在电话机上、能剖析来电者声音的新机器。据说那种机器能让商人知道他的朋友或客户是否在撒谎，其出错概率很小。
 
16    All this is being done in the name of "security"; that is what we tell ourselves. We are fearful, and so we devise ways to lock the fear out, and that, we decide, is what security means.
 
      所有这一切都是以“安全”的名义实施的：我们是这么跟自己说的。我们害怕，于是我们设法把害怕锁在外面，我们认定，那就是安全的意义。
 
17    But no; with all this "security," we are perhaps the most insecure nation in the history of civilized man. What better word to describe the way in which we have been forced to live? What sadder reflection on all that we have become in this new and puzzling time?
 
      其实不然；我们虽然有了这一切安全措施，但我们或许是人类文明史上最不安全的国民。还有什么更好的字眼能用来描述我们被迫选择的生活方式呢？还有什么更为可悲地表明我们在这个令人困惑的新时代所感受到的惶恐之情呢？
 
18    We trust no one. Suburban housewives wear rape whistles on their station wagon key chains. We have become so smart about self-protection that, in the end, we have all outsmarted ourselves. We may have locked the evils out, but in so doing we have locked ourselves in.
 
      我们不信任任何人。郊区的家庭主妇在客货两用车钥匙链上挂着防强暴口哨。我们在自我防卫方面变得如此聪明，最终聪明反被聪明误。我们或许是把邪恶锁在了门外，但在这么做的同时我们把自己锁在里边了。
 
19    That may be the legacy we remember best when we look back on this age: In dealing with the unseen horrors among us, we became prisoners of ourselves. All of us prisoners, in this time of our troubles.
 
      那也许是我们将来回顾这一时代时记得最牢的精神遗产：在对付我们中间无形的恐惧之时，我们成了自己的囚徒。在我们这个问题重重的时代，所有的人都是囚徒。
 
 
 
  大家好，我叫亓官劼（qí guān jié ），在CSDN中记录学习的点滴历程，时光荏苒，未来可期，加油~博客地址为：亓官劼的博客
 
 
 
  
本文原创为亓官劼，请大家支持原创，部分平台一直在盗取博主的文章！！！
 
 
 
 
博主目前仅在CSDN中写博客，唯一博客更新的地址为：亓官劼的博客