使用MySQL

添加相应的依赖

1
2
3
4
5
6
7
8
9
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.15</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

实体建模

创建一些对象与数据库的表建立映射关系
假如数据库的E-R图如下：
u13XaF.png

我们根据E-R图得到相应的pojo

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
@Entity
@Table(name ="user")
public class User implements java.io.Serializable{
    @Id      //定义记录的唯一标识
    @GeneratedValue(strategy = GenerationType.IDENTITY) //设置为自动生成
    private Long id;

    private String name;

    //日期类型必须进行格式化
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date createdate;

    //定义一对多关系
    @ManyToOne
    @JoinColumn(name = "did")
    @JsonBackReference
    private  Deparment deparment;

    //定义多对多关系
    @ManyToMany(cascade = {},fetch = FetchType.EAGER)
    @JoinTable(name = "user_role",joinColumns = {@JoinColumn(name = "user_id")},
            inverseJoinColumns ={@JoinColumn(name = "roles_id")} )
    private List<Role> roles;

    //getter setter
    }
1
2
3
4
5
6
7
8
9
10
@Entity
@Table(name = "role")
public class Role  implements java.io.Serializable{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    //getter setter
    }
1
2
3
4
5
6
7
8
9
10
11
@Entity
@Table(name = "deparment")
public class Deparment {

    @Id //定义为记录的唯一标识
    @GeneratedValue(strategy = GenerationType.IDENTITY) //设置为自动生成
    private Long id;

    private String name;
    //getter setter
}

值得注意的是，这里出现了很多的注解，不过jpa注解都能查到。
常见的有@OneToOne @OneToMany @ManyToOne @ManyToMany @Join

一个总结得很好的博客

实体持久化

实体持久化非常的简单，只用一个接口需要继承JpaRepository<T,ID>即可

1
2
3
@Repository
public interface UserRepository extends JpaRepository<User,Long> {
}

它提供了许多的常用的方法：
u1wHfK.png

配置文件

1
2
3
4
5
6
7
8
9
10
spring:
  datasource:
      url: jdbc:mysql://localhost:3306/springboot_study?useSSL=FALSE&serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&rewriteBatchedStatements=true
      username: root
      password: 123456
  jpa:
    database: mysql
    show-sql: true
    hibernate:
      ddl-auto: update #使用Hibernate自动更新表的结构

测试程序

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
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootStudyApplicationTests {

    @Autowired
    UserRepository userRepository;

    @Autowired
    RoleRepository roleRepository;
    @Autowired
    DepartmentRepository departmentRepository;
    @Test
    public void contextLoads() {
        Deparment deparment=new Deparment();
        deparment.setName("开发部");
        departmentRepository.save(deparment);

        Role role=new Role();
        role.setName("admin");
        roleRepository.save(role);

        User user=new User();
        user.setName("小明");
        user.setCreatedate(new Date());
        user.setDeparment(deparment);

        List<Role> list = roleRepository.findAll();
        user.setRoles(list);

        userRepository.save(user);

    }

}

程序完美运行，数据库中的表也被自动的建好了
u10AXQ.png

Redis

Redis是一种可以用于持久存储的缓存系统，是一个高性能的key-value数据库。

导入相应的依赖

1
2
3
4
5
6
7
8
9
10
11
12
<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-redis</artifactId>
    <version>RELEASE</version>
</dependency>
<!--gson-->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.5</version>
</dependency>

初始化RedisTemplate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Configuration
public class RedisConfiguration {

    @Bean
    public RedisTemplate<String,String> redisTemplate(RedisConnectionFactory factory){
        StringRedisTemplate template=new StringRedisTemplate(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer
                =new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om=new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return  template;

    }
}

编写Redis服务类

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

@Repository
public class UserRedis {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    public void add(String key, Long time, User user){
        Gson gson=new Gson();
        redisTemplate.opsForValue().set(key,gson.toJson(user),time, TimeUnit.MINUTES);
    }
    public void add(String key, Long time, List<User> users){
        Gson gson=new Gson();
        redisTemplate.opsForValue().set(key,gson.toJson(users),time, TimeUnit.MINUTES);
    }


    public User get(String key){
        Gson gson=new Gson();
        User user=null;
        String json = redisTemplate.opsForValue().get(key);
        if(!StringUtils.isEmpty(json)){
            user=gson.fromJson(json,User.class);

        }
        return user;
    }

    public void delete(String key){
        redisTemplate.opsForValue().getOperations().delete(key);
    }
    //只简单的实现几个方法
}

填写配置文件

1
2
3
4
5
6
7
8
9

redis:
  host: localhost
  port: 6379
  pool:
    max-active: 8
    max-idle: 8
    max-wait: -1
    min-idle: 0

编写测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void RedisTest(){
    //省略创建并初始化user对象的过程

    userRedis.add(String.valueOf(user.getId()),1L,user);

    User userFromRedis= userRedis.get(String.valueOf(user.getId()));
    Assert.assertNotNull(userFromRedis);
    System.out.println(userFromRedis.toString());
    userRedis.delete(String.valueOf(user.getId()));
    userFromRedis= userRedis.get(String.valueOf(user.getId()));
    Assert.assertNull(userFromRedis);


}

使用mongoDB

导入相关的依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<!--mongoDB-->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-mongodb</artifactId>
</dependency>
<dependency>
    <groupId>org.pegdown</groupId>
    <artifactId>pegdown</artifactId>
    <version>1.2.1</version>
</dependency>
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-boot-starter-hateoas</artifactId>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.0</version>
</dependency>

实体建模

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Document(collection = "student")
public class Student {
    @Id
    private String userId;

    @NotNull @Indexed(unique=true)
    private String username;

    @NotNull
    private String name;

    public Student(){}

    @PersistenceConstructor
    public Student(String userId, @NotNull String username, @NotNull String name) {
        this.userId = userId;
        this.username = username;
        this.name = name;
    }
}

文档持久化

1
2
public interface StudentRepository extends MongoRepository<Student,String> {
}

编写配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Configuration
@EnableMongoRepositories(basePackages = "com.example.springbootstudy.MongoDao")
@PropertySource("classpath:mongoDBTest.properties")
public class MongoDBConfig  extends AbstractMongoConfiguration {

    @Autowired
    private Environment env;

    @Override
    @Bean
    public MongoClient mongoClient() {
        ServerAddress serverAddress=new ServerAddress(env.getRequiredProperty("mongo.host"));
        List<MongoCredential> credentials=new ArrayList<>();
        return new MongoClient(serverAddress,credentials);

    }

    @Override
    protected String getDatabaseName() {
       return env.getProperty("mongo.name");
    }
}

编写配置文件

1
2
3
4
# mongoDBTest.properties文件
mongo.host=localhost
mongo.name=test
mongo.port=27017

测试代码

1
2
3
4
5
6
7
8
9
10
@Test
public void mongoDBTest(){
    Student student=new Student("1","12346","小明");
    studentRepository.save(student);
    List<Student> list=studentRepository.findAll();
    Assert.assertNotNull(list);
    for(Student stu:list){
        System.out.println(stu.toString());
    }
}
java技术SpingBoot
许可协议

本文采用 署名-非商业性使用-相同方式共享 4.0 国际 许可协议，转载请注明出处。

快来参与讨论吧~