Steam免費送出太空策略建造遊戲《火星求生》

阿新 • • 發佈：2021-09-08

JPA

簡介

JPA 是 Java Persistence API 的簡稱，是一套 Sun 公司 Java 官方制定的 ORM（Object Relational Mapping）方案，是規範、是標準，Sun 公司自己並沒有實現；
市場上的主流的 JPA 框架有：Hibernate （JBoos）、EclipseTop（Eclipse社群）、OpenJPA （Apache基金會），Hibernate 是眾多實現者之中，效能最好的，我們引入的 JPA 框架，採用Hibernate實現，需要注意的是，引用是 javax.persistence 這個“標準”包，和 org.hibernate 實現包；
JPA 想要做的就是儘量讓你少寫 Sql，甚至不寫 Sql，基於這種思想，JPA 實現了它自己的一套語法、註解規則，JPA 要用各種註解配合來實現資料實體間一對多、多對多等關聯關係，正因為這樣，個人覺得實體變得不那麼單純，摻雜了邏輯在裡面，這增加了實體的複雜度，對於比較複雜的業務來說，很容易造成實體間直接或間接的迴圈引用；
在此，我們引入將引入 Spring Data Jpa，在 JPA 之上新增另一層抽象（Repository 層的實現），極大地簡化持久層開發；
Hibernate、JPA、Spring Data Jpa 之間的關係如下：

引入 Jar

spring-context

spring-orm
mysql-connector-java
c3p0
hibernate-core
spring-data-jpa
---------------- 已經引入的部分忽略 ----------------

1 <wiz_code_mirror> 1

<!-- Spring data jpa -->

<dependency>

    <groupId>org.springframework.data</groupId>

    <artifactId>spring-data-jpa</artifactId>

    <version>2.3.4.RELEASE</version>

</dependency>

配置

配置結構

applicationContext.xml ---- 全域性配置，為了避免該檔案雜亂，我們按功能拆分為子配置檔案；

引入 jdbcParms.properties ---- Jdbc 配置資訊；
引入 hibernateParms.properties ---- Hibernate 配置屬性資訊；
引入 springJpa.xml ---- JPA 注入 Spring 配置；

applicationContext.xml

1 <wiz_code_mirror> 1

<!-- 載入屬性檔案 -->

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

    <property name="locations">

       <list>

          <value>classpath:config/properties/jdbcParms.properties</value>

          <value>classpath:config/properties/hibernateParms.properties</value>

        </list>

    </property>

</bean>

<!-- 引入別的配置檔案 -->

<import resource="springJpa.xml"/>

hibernateParms.properties

參見 Hibernate 相關配置；

springJpa.xml

配置鏈

dataSource ---- entityManagerFactory ---- transactionManager ---- jpa:repositories；

1 <wiz_code_mirror> 1

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xmlns:tx="http://www.springframework.org/schema/tx"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:jpa="http://www.springframework.org/schema/data/jpa"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context-3.0.xsd

        http://www.springframework.org/schema/mvc

        http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

        http://www.springframework.org/schema/tx

        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

        http://www.springframework.org/schema/data/jpa

        http://www.springframework.org/schema/data/jpa/spring-jpa.xsd" >

    <!-- 資料來源，spring jdbc || c3p0 jdbc -->

    <!-- <bean id="dataSourceForJpa" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

        <property name="driverClassName" value="${jdbc.driverClassName}"/>

        <property name="url" value="${jdbc.url}"/>

        <property name="username" value="${jdbc.username}"/>

        <property name="password" value="${jdbc.password}"/>

    </bean> -->

    <!-- 配置 c3p0 資料來源 -->

    <bean id="dataSourceForJpa" class="com.mchange.v2.c3p0.ComboPooledDataSource">

        <property name="driverClass" value="${jdbc.driverClassName}" />

        <property name="jdbcUrl" value="${jdbc.url}" />

        <property name="user" value="${jdbc.username}" />

        <property name="password" value="${jdbc.password}" />

        <!-- 連線池中連線用完時，c3p0 一次性建立的連線數 -->

        <property name="acquireIncrement" value="${pool.acquireIncrement}" />

        <!-- 初始化連線數，在 minPoolSize 和 maxPoolSize 之間 -->

        <property name="initialPoolSize" value="${pool.initialPoolSize}" />

        <property name="minPoolSize" value="${pool.minPoolSize}" />

        <property name="maxPoolSize" value="${pool.maxPoolSize}" />

        <!-- 連線關閉時預設將所有未提交的操作回滾,預設為 false -->

        <property name="autoCommitOnClose" value="${pool.autoCommitOnClose}"/>

    </bean>

    <!-- 配置 entityManagerFactory -->

    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">

        <!-- 設定資料來源 -->

        <property name="dataSource" ref="dataSourceForJpa" />

        <!-- 掃描 Entity 包 -->

        <property name="packagesToScan" value="com.sfac.springMvc.module.*.entity" />

        <!-- 指定 JPA 實現廠商 -->

        <property name="persistenceProvider">

            <bean class="org.hibernate.jpa.HibernatePersistenceProvider" />

        </property>

        <!-- 指定 JPA 供應商介面卡 -->

        <property name="jpaVendorAdapter">

            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />

        </property>

        <!-- 配置 JPA 屬性 -->

        <property name="jpaProperties">

            <props>

                <!-- 動態生成表策略 -->

                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>

                <!-- 命名規則隱式策略 -->

                <prop key="hibernate.implicit_naming_strategy">${hibernate.implicit_naming_strategy}</prop>

                <!-- 資料庫方言 -->

                <prop key="hibernate.dialect">${hibernate.dialect}</prop>

                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>

                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>

            </props>

        </property>

    </bean>

    <!-- 配置事務管理器 -->

    <bean id="jpaTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">

        <property name="entityManagerFactory" ref="entityManagerFactory" />

    </bean>

    <!-- 開啟事務註解 -->

    <tx:annotation-driven transaction-manager="jpaTransactionManager"/>

    <!-- 配置 repository -->

    <jpa:repositories base-package="com.sfac.springMvc.module.*.repository"

        transaction-manager-ref="jpaTransactionManager"

        entity-manager-factory-ref="entityManagerFactory" />

</beans>

應用

主要介面和實現類

Repository

屬性查詢

介面方法命名：

findBy + 屬性 + 關鍵字 + 屬性（option）；
find + Top || First（option） +By +屬性 + 關鍵字 + 屬性（option）；

查詢關鍵字列表

And ---- findByLastnameAndFirstname ---- … where x.lastname = ?1 and x.firstname = ?2；
Or ---- findByLastnameOrFirstname ---- … where x.lastname = ?1 or x.firstname = ?2；
Is,Equals ---- findByFirstname,findByFirstnameIs,findByFirstnameEquals ---- … where x.firstname = ?1；
Between ---- findByStartDateBetween ---- … where x.startDate between ?1 and ?2；
LessThan ---- findByAgeLessThan ---- … where x.age < ?1；
LessThanEqual ---- findByAgeLessThanEqual ---- … where x.age <= ?1；
GreaterThan ---- findByAgeGreaterThan ---- … where x.age > ?1；
GreaterThanEqual ---- findByAgeGreaterThanEqual ---- … where x.age >= ?1；
After ---- findByStartDateAfter ---- … where x.startDate > ?1；
Before ---- findByStartDateBefore ---- … where x.startDate < ?1；
IsNull ---- findByAgeIsNull ---- … where x.age is null；
IsNotNull,NotNull ---- findByAge(Is)NotNull ---- … where x.age not null；
Like ---- findByFirstnameLike ---- … where x.firstname like ?1；
NotLike ---- findByFirstnameNotLike ---- … where x.firstname not like ?1；
StartingWith ---- findByFirstnameStartingWith ---- … where x.firstname like ?1 (parameter bound with appended %)；
EndingWith ---- findByFirstnameEndingWith ---- … where x.firstname like ?1 (parameter bound with prepended %)；
Containing ---- findByFirstnameContaining ---- … where x.firstname like ?1 (parameter bound wrapped in %)；
OrderBy ---- findByAgeOrderByLastnameDesc ---- … where x.age = ?1 order by x.lastname desc；
Not ---- findByLastnameNot ---- … where x.lastname <> ?1；
In ---- findByAgeIn(Collection<Age> ages) ---- … where x.age in ?1；
NotIn ---- findByAgeNotIn(Collection<Age> ages) ---- … where x.age not in ?1；
True ---- findByActiveTrue() ---- … where x.active = true；
False ---- findByActiveFalse() ---- … where x.active = false；
IgnoreCase ---- findByFirstnameIgnoreCase ---- … where UPPER(x.firstame) = UPPER(?1)；

@Query 註解查詢；

查詢語言

SQL 語言

關係型資料庫查詢語言；
select name, age, user_id from t_user;
JPA 中使用 Sql 語句，只需註解中新增引數 nativeQuery = true 即可；

HQL 語言

Hibernate 造出來的物件語言，只有 Hibernate 框架能夠解析，並將其通過一系列的對映轉換，拼湊成 SQL 語言；
使用 “類名” 取代 “表名”，用 “類名.屬性名” 取代 “表名.列名”，類名建議不要省略；
沒有 * 查詢，使用 from 類名代替；
查詢操作使用 @Query 註解
刪除修改操作使用 @Modifying + @Transactional +@Query註解，@Transactional 可加在 service 層；

JPQL 語言

EJB3.0 中的 JPA 造出來的物件查詢語言，其原型類似於 HQL，Sun 看到 Hibernate 做的 ORM 技術做的非常好，成為行業內領導 ORM 框架的主流產品，故 Sun 將其吸收進 EJB3 中，制定了一套 ORM 的 JAVA API 標準；

傳參方式

select name,age,userId from User where userName = ?1; ---- ?加數字表示佔位符，從 1 開始；
select name,age,userId from User where userName=:userName; ---- :加上變數名，這裡是與方法引數中有 @PARAM 的值匹配；

CrudRepository

添加了對資料的增刪改查的方法；

PagingAndSortingRepository

添加了對資料的分頁和排序方法；

QueryByExampleExecutor

Example 條件查詢；

JpaRepository

對繼承父介面中方法的返回值進行了適配，在父類介面中通常都返回迭代器，需要我們自己進行強制型別轉化，而在 JpaRepository 中，直接返回了 List；

JpaSpecificationExecutor

主要提供了多條件查詢的支援，並且可以在查詢中新增分頁和排序，因為這個介面單獨存在，因此需要配合以上說的介面使用；

QueryDslPredicateExecutor
SimpleJpaRepository ---- 實現類；
QueryDslJpaRepository ---- 實現類；

新增介面

針對每個 Bean 書寫一個持久層介面，繼承 JpaRepository<T, ID> 介面（其中 T 是實體 bean， ID 是主鍵），新增 @Repository 註解，到此，我們一行程式碼都不用寫，即可呼叫父介面實現功能；
StudentRepository.java

1 <wiz_code_mirror> 1

@Repository

public interface StudentRepository extends JpaRepository<Student, Integer> {

StudentServiceImpl.java

1 <wiz_code_mirror> 1

@Autowired

private StudentRepository studentRepository;

@Override

@Transactional("jpaTransactionManager")

public ResultEntity<Student> insertStudentForJpa(Student student) {

    studentRepository.saveAndFlush(student);

    return new ResultEntity<Student>(ResultStatus.SUCCESS.status, "Insert success.", student);

StudentController.java

1 <wiz_code_mirror> 1

/**

 * 127.0.0.1/api/jpa/student ---- post

 * {"studentName":"HymanHu"}

 * {"studentName":"HymanHu", "studentCard":{"cardNo":"studentCard001"}}

*/

@PostMapping(value = "/jpa/student", consumes = "application/json")

public ResultEntity<Student> insertStudentForJpa(@RequestBody Student student) {

    return studentService.insertStudentForJpa(student);

修改介面

StudentServiceImpl.java

1 <wiz_code_mirror> 1

@Override

@Transactional("jpaTransactionManager")

public ResultEntity<Student> updateStudentForJpa(Student student) {

    studentRepository.saveAndFlush(student);

//  int i = 1 / 0;

    return new ResultEntity<Student>(ResultStatus.SUCCESS.status, "Update success.", student);

StudentController.java

1 <wiz_code_mirror> 1

/**

 * 127.0.0.1/api/jpa/student ---- put

 * {"id":"2","studentName":"HymanHu1"}

 * {"id":"2","studentName":"HymanHu1","studentCard":{"id":"1","cardNo":"studentCard002"}}

*/

@PutMapping(value = "/jpa/student", consumes = "application/json")

public ResultEntity<Student> updateStudentForJpa(@RequestBody Student student) {

    return studentService.updateStudentForJpa(student);

刪除介面

StudentServiceImpl.java

1 <wiz_code_mirror> 1

@Override

public ResultEntity<Object> deleteStudentForJpa(Integer id) {

    studentRepository.deleteById(id);

    return new ResultEntity<Object>(ResultStatus.SUCCESS.status, "Delete success.");

StudentController.java

1 <wiz_code_mirror> 1

/**

 * 127.0.0.1/api/jpa/student/2 ---- delete

*/

@DeleteMapping("/jpa/student/{id}")

public ResultEntity<Object> deleteStudentForJpa(@PathVariable Integer id) {

    return studentService.deleteStudentForJpa(id);

父介面查詢

StudentServiceImpl.java

1 <wiz_code_mirror> 1

@Override

public Student getStudentByIdForJpa(Integer id) {

    return studentRepository.findById(id).orElse(null);

@Override

public List<Student> getStudentsForJpa() {

    return studentRepository.findAll();

StudentController.java

1 <wiz_code_mirror> 1

/**

 * 127.0.0.1/api/jpa/student/9 ---- get

*/

@GetMapping("/jpa/student/{id}")

public Student getStudentByIdForJpa(@PathVariable Integer id) {

    return studentService.getStudentByIdForJpa(id);

/**

 * 127.0.0.1/api/jpa/students ---- get

*/

@GetMapping("/jpa/students")

public List<Student> getStudentsForJpa(@RequestParam(required = false) String studentName) {

    return studentService.getStudentsForJpa();

Example && Criteria 查詢

JpaRepository：<S extends T> Page<S> findAll(Example<S> example, Pageable pageable);

Example：動態條件查詢樣本 ----static <T> Example<T> of(T probe, ExampleMatcher matcher)；

T：實體 bean；
ExampleMatcher：查詢匹配器；

ExampleMatcher.matchingAny() ---- 匹配條件是 or 的關係；
ExampleMatcher.matching() ---- 匹配條件是 and 的關係；
withMatcher("studentName", match -> match.contains()) ---- 模糊查詢，即 %studentName%；
withIgnorePaths("studentId", "createDate"); ---- 忽略欄位，可以自動忽略空值的欄位，但 id 是基本資料型別，預設值為 0，必須忽略；

Pageable：分頁元件 ---- public static PageRequest of(int page, int size, Sort sort)；

page：當前頁，從 0 開始；
size：每頁大小；
sort：排序物件 ---- new Sort(direction, orderBy)；

direction：排序方向，Sort.Direction.ASC；
orderBy：排序欄位；

Page：返回分頁物件；

JpaSpecificationExecutor：Page findAll(@Nullable Specification<T> spec, Pageable pageable);

Specification：Criteria 多條件查詢，支援時間比較、數字比較等；
Pageable
Page

StudentRepository.java

1 <wiz_code_mirror> 1

@Repository

public interface StudentRepository extends JpaRepository<Student, Integer>, JpaSpecificationExecutor<Student> {

StudentServiceImpl.java

1 <wiz_code_mirror> 1

@Override

public Page<Student> getStudentsBySearchBeanForJpa(SearchBean searchBean) {

    searchBean.initSearchBean();

//      Page<Student> page = exampleAndPage(searchBean);

    Page<Student> page = criteriaAndPage(searchBean);

    return page;

/**

 * -實現方式一：Example + Page 查詢

*/

public Page<Student> exampleAndPage(SearchBean searchBean) {

    // 建立 Pageable 物件

    String orderBy = StringUtils.isBlank(searchBean.getOrderBy()) ? "id" : searchBean.getOrderBy();

    Sort.Direction direction = StringUtils.isBlank(searchBean.getDirection()) ||

            searchBean.getDirection().equalsIgnoreCase("asc") ? Sort.Direction.ASC : Sort.Direction.DESC;

    Sort sort = new Sort(direction, orderBy);

    // 當前頁起始為 0

    Pageable pageable = PageRequest.of(searchBean.getCurrentPage() - 1, searchBean.getPageSize(), sort);

    // 建立 Example 物件

    Student student = new Student();

    student.setStudentName(searchBean.getKeyWord());

    student.setCreateDate(LocalDateTime.of(2021, 1, 19, 0, 0));

    // matchingAny 相當於 or 連線查詢條件，matching 相當於 and 連線查詢條件

    ExampleMatcher exampleMatcher = ExampleMatcher.matchingAny()

            // 模糊查詢，即 %{studentName} %

            .withMatcher("studentName", match -> match.contains())

            // 時間型別不支援模糊查詢，生成的語句為createDate=?，同時也不支援 id > startId && id < endId 這樣的操作

            .withMatcher("createDate", match -> match.contains())

            // 忽略基本資料型別欄位，如果使用包裝類則無需忽略

            .withIgnorePaths("id");

    Example<Student> example = Example.of(student, exampleMatcher);

    return studentRepository.findAll(example, pageable);

/**

 * -實現方式：Criteria + Page

*/

public Page<Student> criteriaAndPage(SearchBean searchBean) {

    // 建立 Pageable 物件

    String orderBy = StringUtils.isBlank(searchBean.getOrderBy()) ? "id" : searchBean.getOrderBy();

    Sort.Direction direction = StringUtils.isBlank(searchBean.getDirection()) ||

            searchBean.getDirection().equalsIgnoreCase("asc") ? Sort.Direction.ASC : Sort.Direction.DESC;

    Sort sort = new Sort(direction, orderBy);

    // 當前頁起始為 0

    Pageable pageable = PageRequest.of(searchBean.getCurrentPage() - 1, searchBean.getPageSize(), sort);

    // 建立 Specification 物件

    Specification<Student> specification = new Specification<Student>() {

        private static final long serialVersionUID = 1L;

/**

         * -構造語句 select * from test_student where createDate>=? and

         * (studentName like ? or id between 10 and 20) order by id desc limit ?

*/

        @Override

        public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query,

                CriteriaBuilder criteriaBuilder) {

            return criteriaBuilder.and(

                criteriaBuilder.greaterThanOrEqualTo(

                    root.get("createDate").as(LocalDateTime.class),

                    LocalDateTime.of(2021, 1, 20, 0, 0)),

                criteriaBuilder.or(

                    criteriaBuilder.like(root.get("studentName").as(String.class),

                            String.format("%%%s%%", searchBean.getKeyWord())),

                    criteriaBuilder.between(root.get("id"), 10, 20)

);

};

    return studentRepository.findAll(specification, pageable);

StudentController.java

1 <wiz_code_mirror> 1

/**

 * 127.0.0.1/api/jpa/students ---- post

 * {"currentPage":1, "pageSize":5, "keyWord":"hy", "orderBy":"id", "direction":"desc"}

 * {"currentPage":1, "pageSize":5, "keyWord":"hu", "orderBy":"studentName", "direction":"asc"}

 * -注意：排序欄位不能使用下劃線

*/

@PostMapping(value = "/jpa/students", consumes = "application/json")

public Page<Student> getStudentsBySearchBeanForJpa(@RequestBody SearchBean searchBean) {

    return studentService.getStudentsBySearchBeanForJpa(searchBean);

屬性查詢

StudentRepository.java

1 <wiz_code_mirror> 1

List<Student> findByStudentName(String studentName);

StudentServiceImpl.java

1 <wiz_code_mirror> 1

@Override

public Student getStudentByNameForJpa(String studentName) {

    List<Student> students = Optional.ofNullable(studentRepository.findByStudentName(studentName))

            .orElse(Collections.emptyList());

    return students.isEmpty() ? null : students.get(0);

StudentController.java

1 <wiz_code_mirror> 1

/**

 * 127.0.0.1/api/jpa/student?studentName=HymanHu ---- get

*/

@GetMapping("/jpa/student")

public Student getStudentByNameForJpa(@RequestParam String studentName) {

    return studentService.getStudentByNameForJpa(studentName);

Sql && Hql 查詢

StudentRepository.java

1 <wiz_code_mirror> 1

//@Query(nativeQuery = true, value = "select * from test_student where id = :id")

@Query(value = "from Student where id = :id")

Student getStudentById(@Param("id") Integer id);

@Modifying

//@Query(nativeQuery = true, value = "update test_student set student_name = :studentName where id = :id")

@Query(value = "update Student set studentName = :studentName where id = :id")

void updateStudentName(@Param("studentName") String studentName, @Param("id") Integer id);

@Modifying

@Query(nativeQuery = true, value = "update test_student " +

        "set student_name = :#{#student.studentName} where id = :#{#student.id}")

void updateStudent(@Param("student") Student student);

StudentServiceImpl.java

1 <wiz_code_mirror> 1

@Override

public Student getStudentByIdV2ForJpa(Integer id) {

    return studentRepository.getStudentById(id);

@Override

@Transactional("jpaTransactionManager")

public ResultEntity<Student> updateStudentNameForJpa(Student student) {

    studentRepository.updateStudentName(student.getStudentName(), student.getId());

    return new ResultEntity<Student>(ResultStatus.SUCCESS.status, "Update success.", student);

StudentController.java

1 <wiz_code_mirror> 1

/**

 * 127.0.0.1/api/jpa/student/2/v2 ---- get

*/

@GetMapping("/jpa/student/{id}/v2")

public Student getStudentByIdV2ForJpa(@PathVariable Integer id) {

    return studentService.getStudentByIdV2ForJpa(id);

/**

 * 127.0.0.1/api/jpa/student/v2 ---- put

 * {"id":"1","studentName":"HymanHu1"}

*/

@PutMapping(value = "/jpa/student/v2",consumes = "application/json")

public ResultEntity<Student> updateStudentNameForJpa(@RequestBody Student student) {

    return studentService.updateStudentNameForJpa(student);

批量介面

思路

方式一：父介面中有 saveAll、deleteInBatch 方法，可完成批量增刪改操作，在此不做贅述；
方式二：引入 @persistencecontext 註解和 EntityManager 類，屬於 Jpa 包，用途是將 Entity 在記憶體操作，處理完成之後再一次性同步到資料庫，效率要比第一種方式高；

StudentServiceImpl.java

1 <wiz_code_mirror> 1

@PersistenceContext

private EntityManager entityManager;

@Override

@Transactional

public ResultEntity<List<Student>> batchInsertStudentsForJpa(List<Student> students) {

    // 方式一，呼叫父介面完成批量操作

//      studentRepository.saveAll(students);

//      studentRepository.flush();

    // 方式二，引入 entityManager 進行批量操作，效率高於第一種方式

    students.stream().forEach(item -> {

        entityManager.persist(item);

});

    entityManager.flush();

    entityManager.clear();

    return new ResultEntity<List<Student>>(ResultStatus.SUCCESS.status, "Update success.", students);

StudentController.java

1 <wiz_code_mirror> 1

/**

 * 127.0.0.1/api/jpa/students/v2 ---- post

 * [{"studentName":"aa1"},{"studentName":"aa2"}]

*/

@PostMapping(value = "/jpa/students/v2", consumes = "application/json")

public ResultEntity<List<Student>> batchInsertStudentsForJpa(@RequestBody List<Student> students) {

    return studentService.batchInsertStudentsForJpa(students);

練習

建立 User、Role、UserRole、Resource、RoleResource 五個 Bean，使用 Jpa 自動生成表（中間表不要外來鍵關係），使用 Mybatis Or Jpa 實現 User、 Role、Resource 的增刪改查介面；

Steam免費送出太空策略建造遊戲《火星求生》

建造策略遊戲《火星求生（Surviving Mars）》開始在Steam平臺免費領取，但需要注意的是本次免費領取活動在9月9日（明天）凌晨1點就將結束，所以還沒有本作的玩家，需要儘快領取，要知道這款遊戲的正常價格為90元！

Techland 宣佈將於 12 月 9 日在 Steam 免費送出《狂野西部：槍手》

12 月 5 日訊息，近日，開發商 Techland 為慶祝成立 30 週年，宣佈 GOG 平臺的《Crime Cities》現可免費領取，並將於 12 月 9 日在 Steam 平臺免費送出《狂野西部：槍手（Call of Juarez: Gunslinger）》。此前曾報

開發商在Steam免費送出450萬份《狂野西部：槍手》

去年12月9日，Steam平臺開始對註冊使用者送上射擊遊戲《狂野西部：槍手》，而根據該遊戲開發商近日公佈的資訊顯示，在這段免費贈送遊戲的活動期間，這款遊戲共計被Steam使用者領取超過450萬份！

Steam免費送出22元《霓虹深淵》時空陷阱DLC

Steam商城今天（1月28日）正式開啟農曆新年特賣活動的同時，也開始贈送國產橫版地牢遊戲《霓虹深淵》的DLC“時空陷阱”，該DLC原價22元，現在領取可永久入庫，已經擁有《霓虹深淵》的玩家不要錯過本次機會。

太空模擬建造遊戲《月球村》上架Steam 推薦GTX 960

外太空生存基地模擬器《月球村（Moon Village）》現已上架Steam，支援簡體中文。《月球村》模擬了月球上的第一個載人基地，由真實的太空機構計劃，成為人類歷史上第一個新宇宙角的建造者。

太空題材建造遊戲《基地一號》現已在Steam發售

太空基地題材建造遊戲《基地一號》現已在Steam推出，國區售價75元，現發售特惠，售價60元，自帶簡體中文。截止到目前《基地一號》在Steam上的評價為“褒貶不一”。

E3：太空基地建造遊戲《Starmencer》最新宣傳片 8月5日登陸Steam

《Starmencer》是一款由Ominux Games開發、Chucklefish發行的獨立太空基地建設遊戲。該作於今天Future Games Show釋出了最新宣傳視訊。

浮世Focus慶祝遊戲商城開業免費送出PC版《迸發》

今年，法國遊戲發行商浮世Focus開始發力，通過一系列收購逐漸加強在整個遊戲行業的話語權。繼此前修改品牌名稱之後，近日該公司還開放了自家的線上遊戲商城，似乎打算與Steam、Epic、GOG等線上遊戲商店展開競爭。

有機會全球首批拿到量產版驍龍 8 旗艦手機，聯想將在首銷前免費送出部分 moto edge X30

12 月 9 日訊息，摩托羅拉 moto edge X30 手機將於今晚釋出，今日聯想現再次進行預熱，並表示將會抽出 30 位幸運使用者使其早於首銷日便可拿到全球首批量產版驍龍 8 旗艦手機。根據此前預熱資訊，這款手機後置採用雙

訊息稱 Epic 將在聖誕期間每天送出一款神祕遊戲，共 15 款

12 月 12 日訊息，Epic 在本週免費送出的遊戲是《眾神隕落：挑戰者版》和《監獄建築師》，同時宣佈之後還有神祕遊戲送出。目前，Epic 商城官網顯示，神祕遊戲將在 4 天 1 小時 30 分鐘後解鎖。Epic 商城免費介面：點

全國抗疫，騰訊向所有人免費送出 QQ 音樂豪華綠鑽和全民 K 歌 VIP 各 7 天

感謝網友肖戰割割的線索投遞！

喜迎福利任天堂免費送出《噴射戰士2》DLC擴充套件包

任天堂正式公佈了《噴射戰士3》的確切上市日期，距離現在還有不到半年的時間，玩家已經可以開始期待了。而如果覺得這樣的等待時間還是太長，不妨再到《噴射戰士2》裡找找感覺。

Steam 喜加一：建造策略遊戲《火星求生》免費領

9 月 8 日訊息Steam 現有又有一款可以免費領取的遊戲 ——《火星求生》，這是一款建造策略類遊戲，不過該活動 9 月 9 日凌晨 1 點結束，有興趣的玩家不要錯過。

Epic 2020 年度總結：送出超 7 億份免費遊戲，2021 將送出更多

1月30日訊息本週早些時候，Epic 遊戲商城放出了 2020 年的年度回顧並祝賀 2021 新年快樂。官方宣佈：2021 年，Epic 遊戲商城將送出更多的每週免費遊戲。

G 胖 Steam 再送 510 款 7 天免費玩遊戲，其中 9 款不容錯過

Steam 遊戲節開啟，玩家可以在 2 月 4 日到 2 月 10 日的凌晨兩點之間，試玩高達 510 款遊戲，各種各樣的遊戲型別應有盡有。

Epic本週免費遊戲：太空策略RPG《翡翠6：光速版》

新一週的Epic免費遊戲現已開放領取，本次贈送的遊戲為《翡翠6：光速版（Halcyon 6: Lightspeed Edition）》，免費領取時間截止至2月19日凌晨0點。下週將送兩個遊戲，一個是《狂怒2》，另外一個是《絕對漂移》。

Epic 本週免費遊戲已開放領取：太空策略 RPG《翡翠 6：光速版》

2 月 12 日訊息Epic 本週免費遊戲現已開放領取，遊戲為《翡翠 6：光速版（Halcyon 6: Lightspeed Edition）》，免費領取時間截止至 2 月 19 日凌晨 0 點。

Steam喜加一：策略塔防遊戲《Sporadic Spire》免費領

由Contamination Studios製作的策略塔防遊戲《Sporadic Spire》在Steam上開啟了喜加一活動，該作於2020年7月3日發售，目前Steam的26篇評價中好評率佔92%，喜歡的玩家不要錯過。

喜加2！SE送出兩款“勞拉”遊戲在Steam領取

今日（3月18日），SE官方推特公佈了一則好訊息，將送出兩款“勞拉”遊戲啟用碼，分別是《勞拉和奧西里斯神廟》和《勞拉與光之守護者》，在Steam領取。

維珍銀河兩張免費太空遊門票已送出，價值 90 萬美元

11 月 25 日訊息，據外媒報道，美國當地時間週三，維珍銀河公司宣佈，來自加勒比海國家安提瓜與巴布達的健身教練凱莎・沙哈夫 (Keisha Schahaff) 贏得了這家太空旅遊公司兩個亞軌道飛船免費座位，相當於 90 萬美元（

Steam免費送出太空策略建造遊戲《火星求生》

相關推薦