Java

各种配置文件

略

Hibernate

hibernate.cfg.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!--用户名-->
        <property name="hibernate.connection.username">root</property>
        <!--密码-->
        <property name="hibernate.connection.password">123456</property>
        <!--驱动类-->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <!--数据库url-->
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hb?useUnicode=true&amp;characterEncoding=UTF-8
        </property>
        <!--默认的数据库-->
        <property name="hibernate.default_schema">hb</property>
        <!--方言(用于Hibernate来识别各种数据库不同之处)-->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <!-- 用于设置事务提交方式 -->
        <property name="hibernate.connection.autocommit">false</property>

        <!--获得session的方式(getCurrentSession()方法)-->
        <property name="current_session_context_class">thread</property>

        <!-- 设置连接提供者 -->
        <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
        <!-- c3p0连接池的配置 -->
        <property name="hibernate.c3p0.max_size">20</property> <!-- 最大连接池 -->
        <property name="hibernate.c3p0.min_size">5</property> <!-- 最小连接数 -->
        <property name="hibernate.c3p0.timeout">120</property> <!-- 超时 -->
        <property name="hibernate.c3p0.idle_test_period">3000</property> <!-- 空闲连接 -->

        <!--是否把sql语句输出到控制台,方便测试-->
        <property name="show_sql">true</property>
        <!--排版上面的sql语句-->
        <property name="format_sql">true</property>
        <!--测试的时候用,策略create表示每次都会重新创建表,原有数据会丢失-->
        <property name="hbm2ddl.auto">create</property>

        <!--映射-->
        <mapping resource="entity/XXX.hbm.xml"/>

    </session-factory>
</hibernate-configuration>

XXX.hbm.xml

技巧: 级联的时候思考下,是否符合业务逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping
                   schema="数据库库名"
                   catalog="目录名称"
                   default-cascade="级联风格"
                   default-access="访问策略"
                   default-lazy="加载策略"
                   package="包名"
                   auto-import="自动导入">
    <class name="Entry类名"
           table="表名"
           schema="数据库库名"
           batch-size="抓取策略"
           where="条件"
           entity-name="同实体类映射多个表(一般很少用,一般是一个类对应一张表)">
        <id name="类字段名(主键)"
            type="数据类型"
            column="列名"
            length="长度">
            <generator class="主键生成策略"/>
            <column name="数据库列名" sql-type="该列对应的类型"/><!--此写法也可-->
        </id>
        <property name="类字段名(普通列)">
            <column name="数据库列名" sql-type="该列对应的类型" length="长度"/>
        </property>
        <property name="类字段名(普通列)">
            <column name="数据库列名" sql-type="该列对应的类型" length="长度" not-null="是否为空"/>
        </property>

        <!-- 用于连接表,对类中的set集合的设置(一对一,一对多等等) -->
        <set name="students" inverse="true" cascade="delete">
            <key column="gid"/>
            <one-to-many class="com.yuda.entity.Student"/>
        </set>

        <!-- 用于连接表(和set配合使用) -->
        <!--cascade="save-update" 属性让save学生时可以自动生成学生所在的班级-->
        <many-to-one name="gradeByGid" class="com.yuda.entity.Grade" cascade="save-update">
            <column name="gid"/>
        </many-to-one>

        <!-- one-to-one和many-to-many不做说明 -->

        <!--对于实体类内的自定义Bean-->
        <component name="实体类中的引用类型">
          	<property name="类字段名(普通列)">
            	<column name="数据库列名" sql-type="该列对应的类型" length="长度"/>
        	  </property>
            <!--该引用类型的其他字段-->
        </component>

    </class>
</hibernate-mapping>

例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
<!-- 班级表 -->
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>

    <class name="com.yuda.entity.Grade" table="grade" schema="hb">
        <id name="gid">
            <column name="gid" sql-type="int(11)"/>
            <generator class="identity"/>
        </id>
        <property name="gname">
            <column name="gname" sql-type="varchar(20)" length="20"/>
        </property>
        <property name="gdesc">
            <column name="gdesc" sql-type="varchar(50)" length="50" not-null="true"/>
        </property>
        <!-- cascade="delete"当班级表有删除操作,它将会级联到学生表中删除本班级的所有学生 -->
        <set name="students" inverse="true" cascade="delete">
            <key column="gid"/>
            <one-to-many class="com.yuda.entity.Student"/>
        </set>
    </class>
</hibernate-mapping>
<!-- 学生表 -->
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.yuda.entity">

    <class name="Student" table="student" schema="hb">

        <id name="sid">
            <column name="sid" sql-type="int(11)"/>
            <generator class="native"/>
        </id>
        <property name="sname">
            <column name="sname" sql-type="varchar(20)" length="20"/>
        </property>
        <property name="sex">
            <column name="sex" sql-type="char(2)" length="2" not-null="true"/>
        </property>
        <!--cascade="save-update" 属性让save学生时可以自动生成学生所在的班级-->
        <many-to-one name="gradeByGid" class="com.yuda.entity.Grade" cascade="save-update">
            <!-- gid将作为外键存在于学生表 -->
            <column name="gid"/>
        </many-to-one>
    </class>
</hibernate-mapping>

注解的使用(代替xml的存在,注意导包):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
//省
@Entity
@Table(name = "province",schema = "china")
public class Province {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int p_id;

    @Column(name = "p_name",length = 30,nullable = false)
    private String p_name;

    //mappedBy = "city"控制反转,把控制权交给City.class中的province字段
    @OneToMany(targetEntity = City.class,mappedBy = "province")
    @Cascade(CascadeType.SAVE_UPDATE)
    private Set<City> cities = new HashSet<>();

    //...get,set方法自行脑补(注解可以作用在get方法上)
}
//市
@Entity
@Table(name = "city",schema = "china")
public class City {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int c_id;

    @Column(name = "c_name",length = 30,nullable = false)
    private String c_name;

    @JSONField(serialize = false)//FastJson的忽略字段
    @ManyToOne(targetEntity = Province.class)
    @JoinColumn(name = "p_id")
    @Cascade(CascadeType.SAVE_UPDATE)
    private Province province;

    //mappedBy = "city"控制反转,把控制权交给Area.class中的city字段
    @OneToMany(targetEntity = Area.class,mappedBy = "city")
    @Cascade(CascadeType.SAVE_UPDATE)
    private Set<Area> areas = new HashSet<>();

    //...get,set方法自行脑补(注解可以作用在get方法上)
}
//区(县)
@Entity
@Table(name = "area",schema = "china")
public class Area {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int a_id;

    @Column(name = "a_name",length = 30,nullable = false)
    private String a_name;

    @JSONField(serialize = false)//FastJson的忽略字段
    @ManyToOne(targetEntity = City.class)
    @JoinColumn(name = "c_id")
    @Cascade(CascadeType.SAVE_UPDATE)
    private City city;
}

注意:

1
2
3
4
5
6
7
8
//主键生成为uuid的格式为:
    @Id
    @Column(name = "b_id")
    @GenericGenerator(name = "my_uuid", strategy = "uuid")
    @GeneratedValue(generator = "my_uuid")
    public Integer getId() {//注解作用于get方法
        return id;
    }

Struts2

web.xml

1
2
3
4
5
6
7
8
9
10
11
12
<!-- 前端控制器(核心控制器)，只有配置了这个filter我们的strtus2框架才能使用。
Strtus2的默认拦截器(interceptor)它们是在struts-default.xml文件中配置 -->
<filter>
    <filter-name>struts2</filter-name>
    <filter-class>
      org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter
  	</filter-class>
</filter>
<filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

struts.xml

技巧: 可以创建一个主struts.xml文件,内部使用标签来导入其他的配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
        "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
    <!-- Struts2设置 -->
    <constant name="struts.devMode" value="true"/>
    <constant name="struts.i18n.encoding" value="utf-8"/>
    <!-- 等等 -->

    <!--namespace与name联合使用确定一个action
    (例如本例:http://localhost/url組成部分)-->
    <!--extends继承自哪个包,一般为'struts-default'-->
    <!-- abstract="true"代表该包是抽象的-->
    <package name="名字" namespace="/" extends="struts-default">

        <!-- 拦截器配置 -->
        <interceptors>
            <!-- LoginInterceptor和MyInterceptor是自定义的拦截器 -->
            <!-- 自定义拦截器单独使用会导致默认拦截器失效,所以需要把自定义的 -->
            <!-- 和系统的添加为拦截器栈来使用 -->
            <interceptor name="loginInterceptor" class="com.yuda.utils.LoginInterceptor"/>
            <interceptor name="myInterceptor" class="com.yuda.utils.MyInterceptor"/>
            <!-- 合并大法好 -->
            <interceptor-stack name="myStack">
                <interceptor-ref name="defaultStack"/>
                <interceptor-ref name="myInterceptor"/>
                <interceptor-ref name="loginInterceptor"/>
            </interceptor-stack>
        </interceptors>


        <!--全局跳转方式-->
        <global-results>
            <result name="success" type="跳转方式(主要用的有4种)"></result>
            <!--result...-->
        </global-results>
        <!--页面-->
        <action name="url組成部分" class="com.yuda.Struts2Action" method="show">
            <!--成功后跳转的页面-->
            <result name="success" type="跳转方式">/html/success.html</result>
            <result name="error">/html/failer.html</result>
            <!--result...-->
        </action>
        <!--action...-->
    </package>
</struts>

使用注解(代替xml的存在):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
@Namespace(父url)//下面Action的value
@ParentPackage(包名)//继承的包
public class ProductAction extends ActionSupport {
    //url和自定义拦截器,(拦截器需要有父struts.xml文件中package中定义拦截器)
    @Action(value = "showProduct",interceptorRefs = {@InterceptorRef(value = "myStack")})
    //方法还可以返回String类型数据,对应一个页面
    public void showProduct(){
        ServletActionContext.getResponse().setCharacterEncoding("utf-8");
        // 调用service查询所有商品
        IProductService productService = new ProductServiceImpl();
        List<Product> ps = productService.findAll();

        // 将ps转换成json
        Result<Product> result = new Result<>();
        result.setContent(ps);
        result.setType(1);
        String json = JSONArray.toJSONString(result);
        // 通过response将json写回到浏览器
        try {
            ServletActionContext.getResponse().getWriter().write(json);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

//另外一个例子:
@Namespace("/")
@ParentPackage("struts-default")
//类命名并且类的包路径需要包含Action字符
public class UserAction extends ActionSupport implements ModelDriven<User> {
    //有返回的action
    @Action(value = "user_login",results = {
            @Result(name = "success",location = "/product.jsp"),
            @Result(name = "error",location = "/login.jsp")
    })
    public String login(){

        IUserService service = new UserService();

        User login = service.login(user);

        if (login == null){
            return ERROR;
        } else {
            ServletActionContext.getRequest().getSession().setAttribute("user",login);
            return SUCCESS;
        }
    }

    private User user = new User();

    @Override
    public User getModel() {
        return user;
    }
}

Spring

Spring.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
                           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd"
       profile="dev">
  
 	<context:annotation-config/><!-- 启动注解-->
  	<!-- 启动注解后这些注解可以检测到
		@Component	//无分类
		@Repository	//持久层
		@Controller //控制层
		@Service	//业务层
	-->
  
	<bean class = "类路径"/><!-- 导入JavaConfig-->
  
  	<import resource = "XXX.xml"/><!-- 导入XML-->
  
  <!--数据库相关START-->
  <context:property-placeholder location="classpath*:c3p0.properties"/>
  <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource"
        p:driverClassName="${jdbc.driverClass}"
        p:url="${jdbc.jdbcUrl}"
        p:username="${jdbc.user}"
        p:password="${jdbc.password}"/>
  <!--普通事务管理器(可选择)-->
  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  	<!-- JPA事务管理器(可选择,需要entityManagerFactory)  -->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>
  <!--使用注解-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
  <!--不使用注解,xml方式-->
  <!--事务的通知-->
  <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
      <tx:method name="account" propagation="REQUIRED"/>
    </tx:attributes>
  </tx:advice>
  <!--配置切面-->
  <aop:config>
    <aop:pointcut id="txPointcut" expression="execution(* com.yuda.IAccountService.account(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
  </aop:config>
  <!--数据库相关END-->
  
	<!--声明集合-->
    <util:list id="my_list">
        <value>1</value>
        <value>1</value>
        <value>1</value>
        <value>1</value>
        <value>1</value>
    </util:list>
	<!--init-method和destroy-method是bean生命周期中执行的方法-->
    <bean id="peppers" class="com.yuda.component.SgtPeppers"  
          init-method="toString" destroy-method="toString"/>

    <bean id="peppers2" class="com.yuda.component.SgtPeppers" scope="prototype"/>

    <bean id="cdplayer1" class="com.yuda.component.CDPlayer">
        <constructor-arg ref="peppers"/>
    </bean>
    
    <bean id="cdplayer2" class="com.yuda.component.CDPlayer" p:cd-ref="peppers"/>

    <bean id="cdplayer3" class="com.yuda.component.CDPlayer">
        <property name="cd" ref="peppers"/>
    </bean>

    <bean id="blank" class="com.yuda.component.BlankDisc"
          c:title="aaa"
          c:artist="bbb" c:tracks-ref="my_list">
    </bean>

</beans>

Spring使用c3p0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
<bean id="dataSource2" class="com.mchange.v2.c3p0.ComboPooledDataSource"
      destroy-method="close">
  <property name="driverClass" value="${jdbc.driverClass}"/>
  <property name="jdbcUrl" value="${jdbc.jdbcUrl}"/>
  <property name="user" value="${jdbc.user}"/>
  <property name="password" value="${jdbc.password}"/>
  <!--连接池中保留的最小连接数。-->
  <property name="minPoolSize" value="5"/>

  <!--连接池中保留的最大连接数。Default: 15 -->
  <property name="maxPoolSize" value="30"/>

  <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
  <property name="initialPoolSize" value="10"/>

  <!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
  <property name="maxIdleTime" value="60"/>

  <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
  <property name="acquireIncrement" value="5"/>

  <!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements
           属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
           如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0-->
  <property name="maxStatements" value="0"/>

  <!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
  <property name="idleConnectionTestPeriod" value="60"/>

  <!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
  <property name="acquireRetryAttempts" value="30"/>

  <!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效
           保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试
           获取连接失败后该数据源将申明已断开并永久关闭。Default: false-->
  <property name="breakAfterAcquireFailure" value="true"/>

  <!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的
           时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
           等方法来提升连接测试的性能。Default: false -->
  <property name="testConnectionOnCheckout" value="false"/>
</bean>

Spring-aop相关

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    
<!-- 开启aop注解 -->
<aop:aspectj-autoproxy proxy-target-class="true"/>
<!-- 如果不用注解,可以使用如下xml -->
<aop:config expose-proxy="true" proxy-target-class="true">

  <aop:pointcut id="test_point_cut" expression="execution(* com.yuda.component.MyTest.*(..))"/>

  <aop:aspect ref="my_advice">

    <aop:before method="before" pointcut-ref="test_point_cut"/>

    <aop:after method="after" pointcut-ref="test_point_cut"/>

    <aop:around method="around" pointcut-ref="test_point_cut"/>

    <aop:after-returning method="afterReturning" pointcut-ref="test_point_cut" returning="val"/>

  </aop:aspect>
</aop:config>

Spring加入web

web.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath*:Spring-ioc.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

log4j

log4j.properties

1
2
3
4
5
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=warn, stdout

maven

settings.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
    <localRepository>D:\apache-maven-3.1.1\repository</localRepository>
    <pluginGroups></pluginGroups>
  	<proxies></proxies>
    <servers></servers>
    <mirrors>
      <!-- 阿里爸爸的镜像库,用于国内访问核心库 -->
      <mirror>
        <id>alimaven</id>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
        <mirrorOf>central</mirrorOf>
      </mirror>
    </mirrors>
    <profiles>
      <!-- maven默认工程编译为1.5,这里把它改为1.8-->
      <profile>
        <id>jdk-1.8</id>
        <activation>
          <jdk>1.8</jdk>
          <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
          <maven.compiler.source>1.8</maven.compiler.source>
          <maven.compiler.target>1.8</maven.compiler.target>
          <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
        </properties>
      </profile>
    </profiles>
</settings>

pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<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">
    <!-- 省略一些配置 -->
    <build>
          <plugins>
              <!-- 用于当前项目java编译版本的选择 -->
              <plugin>
                  <groupId>org.apache.maven.plugins</groupId>
                  <artifactId>maven-compiler-plugin</artifactId>
                  <version>2.3.2</version>
                  <configuration>
                      <source>1.8</source>
                      <target>1.8</target>
                  </configuration>
              </plugin>
          </plugins>
      </build>
</project>