Merge pull request giantray#73 from AcceptedBoy/master

giantray · web-flow · commit ac2cf117d0ae · 2016-08-22T19:46:29.000+08:00
【add】How do you assert that a certain exception is thrown in JUnit 4 tests? + and so on
diff --git a/contents/how-can-i-create-an-executable-jar-with-dependencies-using-maven.md b/contents/how-can-i-create-an-executable-jar-with-dependencies-using-maven.md
@@ -0,0 +1,99 @@
+## 如何使用maven把项目及其依赖打包为可运行jar包
+
+#### 问题
+
+我想把java项目打包为可运行的分布式jar包。我该怎样做，才能把项目中maven所依赖的jar包导入到我的项目jar包中？
+
+#### 回答
+
+在`pom.xml`文件中，加入如下的插件：
+
+```xml
+<build>
+  <plugins>
+    <plugin>
+      <artifactId>maven-assembly-plugin</artifactId>
+      <configuration>
+        <archive>
+          <manifest>
+            <!-- 这里是你的项目main函数所在的类的全限定名 -->
+            <mainClass>fully.qualified.MainClass</mainClass> 
+          </manifest>
+        </archive>
+        <descriptorRefs>
+          <descriptorRef>jar-with-dependencies</descriptorRef>
+        </descriptorRefs>
+      </configuration>
+    </plugin>
+  </plugins>
+</build>
+```
+
+之后，运行maven命令：
+
+> mvn clean compile assembly:single
+
+`clean`,`compile`,`assembly:single`任务将会依次被执行；`compile`任务必须写在`assembly:single`之前，否则打包后的jar包内将不会有你的编译代码。
+
+（译注：执行完后，会在你的maven项目的target目录下，生成想要的jar包，而不再需要使用`mvn package`命令进行打包）
+
+通常情况下，上述maven命令执行后会自动绑定到项目的构建阶段，从而保证了以后在执行`mvn install`命令时的jar包也会被构建。
+（译注：下面是实际上完整的默认的`pom.xml`配置，只不过`<executions>`可以被省略，若省略则按照下述默认的配置执行）
+
+```xml
+<plugin>
+  <artifactId>maven-assembly-plugin</artifactId>
+  <configuration>
+    <archive>
+      <manifest>
+        <mainClass>fully.qualified.MainClass</mainClass>
+      </manifest>
+    </archive>
+    <descriptorRefs>
+      <descriptorRef>jar-with-dependencies</descriptorRef>
+    </descriptorRefs>
+  </configuration>
+  <executions>
+    <execution>
+      <id>make-assembly</id> <!-- 用于maven继承项目的聚合 -->
+      <phase>package</phase> <!-- 绑定到package阶段 -->
+      <goals>
+        <goal>single</goal>
+      </goals>
+    </execution>
+  </executions>
+</plugin>
+```
+
+#### 拓展
+
+怎样去运行打包后的可运行jar包？
+
+* 对上述配置中已经指定了`main`函数所在类的jar包，打开命令行窗口，输入命令：
+
+```java
+java -jar jar包的路径/jar包的名字.jar
+```
+
+例如：
+
+```Auto
+java -jar D:\my_java_project\maven_test.jar
+```
+
+* 若在pom.xml并没有指定`main`方法所在类，那么该jar的运行应采取如下命令：
+
+```java
+java -cp jar包的路径/jar包的名字.jar main方法所在类的全限定名
+```
+
+例如:
+
+```java
+java -cp D:\my_java_project\maven_test.jar com.my.path.MainClass
+```
+
+
+#### StackOverflow地址
+
+[http://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven](http://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven)
diff --git a/contents/how-can-i-permanently-have-line-numbers-in-intellij.md b/contents/how-can-i-permanently-have-line-numbers-in-intellij.md
@@ -0,0 +1,29 @@
+## 如何让IntelliJ编辑器永久性显示代码行数
+
+#### 问题
+
+如何让IntelliJ编辑器永久性显示代码行数
+
+#### 回答
+
+##### <Strong>IntelliJ 14.0之后的版本</strong>
+
+打开软件的菜单`File`->`Settings`->`Editor`->`General`->`Appearance`，在右侧的配置`Show line numbers`打勾：
+![image1][1]
+
+##### <Strong>IntelliJ 8.1.2 - 13.X的版本</strong>
+
+打开软件的菜单`File`->`Settings`->`Editor`->`Appearance`，在右侧的配置`Show line numbers`打勾：
+![images2][2]
+
+#### 拓展
+
+[IntelliJ IDEA 使用教程](http://www.phperz.com/article/15/0923/159068.html)
+
+#### StackOverflow地址
+
+http://stackoverflow.com/questions/13751/how-can-i-permanently-have-line-numbers-in-intellij
+
+
+  [1]: http://i.stack.imgur.com/9DL9q.png
+  [2]: http://i.stack.imgur.com/JVZlJ.jpg
diff --git a/contents/how-do-you-assert-that-a-certain-exception-is-thrown-in-junit-4-tests.md b/contents/how-do-you-assert-that-a-certain-exception-is-thrown-in-junit-4-tests.md
@@ -0,0 +1,63 @@
+## JUnit4如何断言确定异常的抛出
+
+#### 问题
+
+在JUnit4单元测试中，我要怎样做才能测试出有特定的异常抛出？我能想到的就只有下面的方法：
+
+```java
+@Test
+public void testFooThrowsIndexOutOfBoundsException() {
+    boolean thrown = false;
+
+    try {
+        foo.doStuff();
+    } catch (IndexOutOfBoundsException e) {
+        thrown = true;
+    }
+
+    assertTrue(thrown);
+}
+```
+
+#### 回答1
+
+在JUnit4后支持下面的写法：
+```java
+@Test(expected=IndexOutOfBoundsException.class)
+public void testIndexOutOfBoundsException() {
+    ArrayList emptyList = new ArrayList();
+    Object o = emptyList.get(0);
+}
+```
+（译者：在`@Test`注解内提供了`expected`属性，你可以用它来指定一个`Throwble`类型，如果方法调用中抛出了这个异常，那么这条测试用例就相当于通过了）
+
+#### 回答2
+
+如果你使用的是JUnit4.7，你可以使用如下的期望异常规则来验证异常信息：
+
+```java
+public class FooTest {
+    @Rule
+    public final ExpectedException exception = ExpectedException.none();
+
+    @Test
+    public void doStuffThrowsIndexOutOfBoundsException() {
+        Foo foo = new Foo();
+
+        exception.expect(IndexOutOfBoundsException.class);
+        foo.doStuff();
+    }
+}
+```
+
+这种方式比`@Test(expected=IndexOutOfBoundsException.class)`要更好，如果是在调用`foo.doStuff()`方法之前就已经抛出异常的话，测试结果就不是我们想要的了。
+（译者：同时，`ExpectedException`还能够验证异常信息，如`exception.expectMessage("there is an exception!");`
+
+#### 拓展阅读
+
+1. [JUnit：使用ExpectedException进行异常测试](http://www.tuicool.com/articles/ANviIz)
+2. [JUnit4 用法详解](http://www.blogjava.net/jnbzwm/archive/2010/12/15/340801.html)
+
+#### StackOverflow地址：
+
+[http://stackoverflow.com/questions/156503/how-do-you-assert-that-a-certain-exception-is-thrown-in-junit-4-tests](http://stackoverflow.com/questions/156503/how-do-you-assert-that-a-certain-exception-is-thrown-in-junit-4-tests)
diff --git a/contents/how-to-create-a-generic-array-in-java.md b/contents/how-to-create-a-generic-array-in-java.md
@@ -0,0 +1,80 @@
+## 如何创建泛型java数组
+
+#### 问题
+
+数组是不能通过泛型创建的，因为我们不能创建不可具体化的类型的数组。如下面的代码：
+
+```java
+public class GenSet<E> {
+    private E a[];
+
+    public GenSet() {
+        a = new E[INITIAL_ARRAY_LENGTH]; //编译期就会报错：不能创建泛型数组
+    }
+}
+```
+
+#### 采纳答案
+
+* 检查：强类型。`GenSet`明确知道数组中包含的类型是什么（例如通过构造器传入`Class<E>`，当方法中传入类型不是`E`将抛出异常）
+
+```java
+public class GenSet<E> {
+
+    private E[] a;
+
+    public GenSet(Class<E> c, int s) {
+        // 使用原生的反射方法，在运行时知道其数组对象类型
+        @SuppressWarnings("unchecked")
+        final E[] a = (E[]) Array.newInstance(c, s);
+        this.a = a;
+    }
+
+    E get(int i) {
+        return a[i];
+    }
+    
+    //...如果传入参数不为E类型，那么强制添加进数组将会抛出异常
+    void add(E e) {...}
+}
+```
+
+* 未检查：弱类型。数组内对象不会有任何类型检查，而是作为Object类型传入。
+
+在这种情况下，你可以采取如下写法：
+
+```java
+public class GenSet<E> {
+
+    private Object[] a;
+
+    public GenSet(int s) {
+        a = new Object[s];
+    }
+
+    E get(int i) {
+        @SuppressWarnings("unchecked")
+        final E e = (E) a[i];
+        return e;
+    }
+}
+```
+
+上述代码在编译期能够通过，但因为泛型擦除的缘故，在程序执行过程中，数组的类型有且仅有`Object`类型存在，这个时候如果我们强制转化为`E`类型的话，在运行时会有`ClassCastException`抛出。所以，要确定好泛型的上界，将上边的代码重写一下：
+
+```java
+public class GenSet<E extends Foo> { // E has an upper bound of Foo
+
+    private Foo[] a; // E 泛型在运行期会被擦除为Foo类型，所以这里使用Foo[]
+
+    public GenSet(int s) {
+        a = new Foo[s];
+    }
+    
+    //...
+}
+```
+
+#### StackOverflow地址：
+
+[http://stackoverflow.com/questions/529085/how-to-create-a-generic-array-in-java](http://stackoverflow.com/questions/529085/how-to-create-a-generic-array-in-java)
diff --git a/contents/whats-the-difference-between-component-repository-service-annotations-in.md b/contents/whats-the-difference-between-component-repository-service-annotations-in.md
@@ -2,21 +2,21 @@
 
 #### 问题
 
-在spring集成的框架中，注解在类上的`@Component`，`@Repository`，`@Service`等注解能否被互换？即这些注解的区别是什么？
+在spring集成的框架中，注解在类上的`@Component`，`@Repository`，`@Service`等注解能否被互换？或者说这些注解有什么区别？
 
 #### 回答1
 
 引用spring的官方文档中的一段描述：
 
-在Spring2.0之前的版本中，`@Repository`注解可以标记在任何的类上，用来表明该类是用来执行与数据库相关的操作（即dao对象）
+在Spring2.0之前的版本中，`@Repository`注解可以标记在任何的类上，用来表明该类是用来执行与数据库相关的操作（即dao对象），并支持自动处理数据库操作产生的异常
 
 在Spring2.5版本中，引入了更多的Spring类注解：`@Component`,`@Service`,`@Controller`。`Component`是一个通用的Spring容器管理的单例bean组件。而`@Repository`, `@Service`, `@Controller`就是针对不同的使用场景所采取的特定功能化的注解组件。
 
 因此，当你的一个类被`@Component`所注解，那么就意味着同样可以用`@Repository`, `@Service`, `@Controller`来替代它，同时这些注解会具备有更多的功能，而且功能各异。
 
 最后，如果你不知道要在项目的业务层采用`@Service`还是`@Component`注解。那么，`@Service`是一个更好的选择。
 
-就如上文所说的，`@Repository`早已被支持了在你的持久层作为一个标记可以去自动处理数据库操作产生的异常（译者注：因为原生的java操作数据库所产生的异常只用了几种，但是产生的原因却有很多种，这样对于数据库操作的报错排查造成了一定的影响；而Spring拓展了原生的持久层异常，针对不同的产生原因有了更多的异常进行描述。所以，在注解了`@Repository`的类上如果数据库操作中抛出了异常，就能对其进行处理，转而抛出的是翻译后的spring专属数据库异常）。
+就如上文所说的，`@Repository`早已被支持了在你的持久层作为一个标记可以去自动处理数据库操作产生的异常（译者注：因为原生的java操作数据库所产生的异常只定义了几种，但是产生数据库异常的原因却有很多种，这样对于数据库操作的报错排查造成了一定的影响；而Spring拓展了原生的持久层异常，针对不同的产生原因有了更多的异常进行描述。所以，在注解了`@Repository`的类上如果数据库操作中抛出了异常，就能对其进行处理，转而抛出的是翻译后的spring专属数据库异常，方便我们对异常进行排查处理）。
 
 | 注解      | 含义           |
 | ------------- |:-------------:|
