springboot_database項目介紹

springboot_database

springboot1.5.7集成mybatis、jpa、redis、mongodb，對不一樣數據庫進行操做的實例
項目代碼獲取：https://github.com/pysasuke/s...

項目結構

main

dao:數據庫交互層

• jpa:jpa與mysql數據庫交互類

public interface JpaUserRepository extends JpaRepository<JpaUser, Long> {

    //jpa有默認實現相似findBy*(支持*And*)方法，其中*號爲實體屬性名(名稱寫的不對會報錯哦)
    JpaUser findByUsername(String username);

    @Query("select count(u.id) from JpaUser u")
    long count();

    @Query("select u from JpaUser u where u.id=:id")
    JpaUser findUserById(@Param("id") long id);
}

• mongo:mongodb數據庫交互類

public interface MongoUserRepository extends MongoRepository<MgUser, Long> {

    //有默認實現相似findBy*(支持*And*)方法，其中*號爲實體屬性名
    MgUser findByNickname(String nickname);

    //根據id爲條件搜索(默認實現的findOne方法是以mongodb中ObjectId爲條件的)
    MgUser findById(Long id);
}

• mybatis:mybatis與mysql數據庫交互類

//@Mapper(SpringbootDatabaseApplication類中使用了@MapperScan註解,故此處能夠省略)
public interface TuserMapper {
    int deleteByPrimaryKey(Long id);

    int insert(Tuser record);

    Tuser selectByPrimaryKey(Long id);

    Tuser selectByUserName(String username);

    int updateByPrimaryKeySelective(Tuser record);

}

entity:實體對象層

• jpa:jpa操做mysql相關實體對象

@Data
@Entity//標記這個類爲數據庫表映射實體
@Table(name="user")//對應數據庫表名
public class JpaUser implements Serializable{
    @Id//標記爲主鍵
    @GeneratedValue//標記主鍵自增
    private Long id;
    private String username;
    private String password;
    private String mobile;
    private String email;
}

• mongo:mongodb相關實體對象

@Data
//須要與mongo中對象(文檔)名一致
public class MgUser {
    @Id
    private ObjectId _id;    //插入mongo時會自動生成_id，若是不加這個字段則會把id屬性當成_id
    @Field
    private Long id;
    private String nickname;
    private String phone;
}

• mybatis:mybatis操做mysql相關實體對象

@Data
public class Tuser {
    private Long id;
    private String username;
    private String password;
    private String mobile;
    private String email;
}

• redis:redis相關實體對象

//redisTemplate操做對象時對象須要實現序列化接口
@Data
public class Person implements Serializable{
    private Long serialVersionUID=1L;
    private Long id;
    private String username;
    private String password;
}

SpringbootDatabaseApplication:springboot啓動類

@SpringBootApplication
// mapper 接口類掃描包配置(能夠省去dao層類上註解@Mapper)
@MapperScan("com.py.springboot_database.dao.mybatis")
public class SpringbootDatabaseApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootDatabaseApplication.class, args);
    }
}

resources

• mapper:mybatis實體類映射文件存放包
• application.properties:springboot配置文件

## 數據源配置
spring.datasource.url=jdbc:mysql://localhost:3306/springboot_database?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=py123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

## Mybatis 配置
##指向實體類包路徑
mybatis.typeAliasesPackage=com.py.springboot_database.entity.mybatis
##配置爲 classpath 路徑下 mapper 包下，* 表明會掃描全部 xml 文件
mybatis.mapperLocations=classpath:mapping/*.xml

## mongodb配置
spring.data.mongodb.uri=mongodb://localhost:27017/test

## Redis 配置
## Redis數據庫索引（默認爲0）
spring.redis.database=0
## Redis服務器地址
spring.redis.host=127.0.0.1
## Redis服務器鏈接端口
spring.redis.port=6379
## Redis服務器鏈接密碼（默認爲空）
spring.redis.password=
## 鏈接池最大鏈接數（使用負值表示沒有限制）
spring.redis.pool.max-active=8
## 鏈接池最大阻塞等待時間（使用負值表示沒有限制）
spring.redis.pool.max-wait=-1
## 鏈接池中的最大空閒鏈接
spring.redis.pool.max-idle=8
## 鏈接池中的最小空閒鏈接
spring.redis.pool.min-idle=0
## 鏈接超時時間（毫秒）
spring.redis.timeout=0

test

• jpa:TestJpa類,jpa操做mysql對象增刪改查操做測試

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = SpringbootDatabaseApplication.class)
public class TestJpa {

    @Autowired
    private JpaUserRepository jpaUserRepository;

    @Test
    public void testInsert() {
        long countBefore =jpaUserRepository.count();
        JpaUser jpaUser = generateJpaUser();
        jpaUserRepository.save(jpaUser);
        long countAfter =jpaUserRepository.count();
        Assert.assertEquals(++countBefore,countAfter);
    }

    @Test
    public void testSelect() {
        JpaUser jpaUser = generateJpaUser();
        /*
        插入成功後id會有值(mysql數據庫生成的)
        前提是：
        1.數據庫主鍵設置爲自動增加
        2.實體對象主鍵屬性上有註解@Id和@GeneratedValue
         */
        jpaUserRepository.save(jpaUser);

        JpaUser selectedJpaUser = jpaUserRepository.findOne(jpaUser.getId());
        Assert.assertNotNull(selectedJpaUser);
        Assert.assertEquals(jpaUser, selectedJpaUser);
    }

    @Test
    public void testUpdate() {
        JpaUser jpaUser = generateJpaUser();
        jpaUserRepository.save(jpaUser);

        JpaUser selectedJpaUser = jpaUserRepository.findOne(jpaUser.getId());
        Assert.assertNotNull(selectedJpaUser);
        selectedJpaUser.setPassword("654321");
        //保存修改後的對象，至關於update操做
        jpaUserRepository.save(selectedJpaUser);
        //findOne(默認實現)方法與findUserById(本身實現)都是根據id查找
        JpaUser updatedJpaUser = jpaUserRepository.findUserById(selectedJpaUser.getId());
        Assert.assertNotNull(updatedJpaUser);
        Assert.assertEquals(selectedJpaUser.getPassword(), updatedJpaUser.getPassword());
    }

    @Test
    public void testDelete() {
        JpaUser jpaUser = generateJpaUser();
        jpaUserRepository.save(jpaUser);

        jpaUserRepository.delete(jpaUser.getId());
        JpaUser selectedJpaUser = jpaUserRepository.findUserById(jpaUser.getId());
        Assert.assertNull(selectedJpaUser);
    }

    private JpaUser generateJpaUser() {
        JpaUser jpaUser = new JpaUser();
        jpaUser.setUsername("zhangsan");
        jpaUser.setPassword("123456");
        jpaUser.setMobile("13666666666");
        jpaUser.setEmail("123456@qq.com");
        return jpaUser;
    }
}

• mongo:TestMongo類,mongodb測試

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = SpringbootDatabaseApplication.class)
public class TestMongo {
    @Autowired
    private MongoUserRepository userRepository;

    @Test
    public void test() {
        MgUser mgUser = new MgUser();
        mgUser.setId(1L);
        mgUser.setNickname("pysasuke");
        mgUser.setPhone("18650140605");
        //插入成功後_id屬性有值(mongo數據庫生成的)
        userRepository.insert(mgUser);
        //該方法使用的是mongodb中ObjectId爲條件的
//        MgUser selectMgUser = userRepository.findOne(1L);
//        MgUser selectMgUser = userRepository.findByNickname("pysasuke");
        MgUser selectMgUser = userRepository.findById(1L);
        Assert.assertEquals(mgUser.getId(), selectMgUser.getId());
    }
}

• mybatis:TestMybatis類,mybatis操做mysql對象增刪改查測試

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = SpringbootDatabaseApplication.class)
public class TestMybatis {

    @Autowired
    private TuserMapper tuserMapper;

    @Test
    public void testInsert() {
        Tuser tuser = generateTuser();
        int row = tuserMapper.insert(tuser);
        Assert.assertEquals(1, row);
    }

    @Test
    public void testSelect() {
        Tuser tuser = generateTuser();
        /*
        插入成功後id會有值(mysql數據庫生成的)
        前提是：
        1.主鍵設置爲自動增加
        2.xml中insert語句設置有:useGeneratedKeys="true" keyProperty="id"
         */
        int row = tuserMapper.insert(tuser);
        Assert.assertEquals(1, row);

        Tuser selectedTuser = tuserMapper.selectByPrimaryKey(tuser.getId());
        Assert.assertNotNull(selectedTuser);
        Assert.assertEquals(tuser, selectedTuser);
    }

    @Test
    public void testUpdate() {
        Tuser tuser = generateTuser();
        int row = tuserMapper.insert(tuser);
        Assert.assertEquals(1, row);

        Tuser selectedTuser = tuserMapper.selectByPrimaryKey(tuser.getId());
        Assert.assertNotNull(selectedTuser);
        selectedTuser.setPassword("654321");
        tuserMapper.updateByPrimaryKeySelective(selectedTuser);

        Tuser updatedTuser = tuserMapper.selectByPrimaryKey(selectedTuser.getId());
        Assert.assertNotNull(updatedTuser);
        Assert.assertEquals(selectedTuser.getPassword(), updatedTuser.getPassword());
    }

    @Test
    public void testDelete() {
        Tuser tuser = generateTuser();
        int row = tuserMapper.insert(tuser);
        Assert.assertEquals(1, row);

        tuserMapper.deleteByPrimaryKey(tuser.getId());
        Tuser selectedTuser = tuserMapper.selectByPrimaryKey(tuser.getId());
        Assert.assertNull(selectedTuser);
    }

    private Tuser generateTuser() {
        Tuser tuser = new Tuser();
        tuser.setUsername("zhangsan");
        tuser.setPassword("123456");
        tuser.setMobile("13666666666");
        tuser.setEmail("123456@qq.com");
        return tuser;
    }
}

• redis:TestRedis類,redis測試

/*
當redis數據庫裏面原本存的是字符串數據或者要存取的數據就是字符串類型數據的時候，
那麼使用StringRedisTemplate便可，
可是若是數據是複雜的對象類型，而取出的時候又不想作任何的數據轉換，直接從Redis裏面取出一個對象，
那麼使用RedisTemplate是更好的選擇。
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = SpringbootDatabaseApplication.class)
public class TestRedis {
    //操做String
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    //操做對象
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testPutString() {
        stringRedisTemplate.opsForValue().set("testPutString", "123456");
    }

    @Test
    public void tesGetString() {
        stringRedisTemplate.opsForValue().set("tesGetString", "123456");
        String str = stringRedisTemplate.opsForValue().get("tesGetString");
        Assert.assertEquals("123456", str);
        //設置緩存時間
        stringRedisTemplate.opsForValue().set("tesGetString", "123456", 1000, TimeUnit.MILLISECONDS);//有效時間1s
        try {
            Thread.sleep(2000);//等待2s(等待設置爲1s的時候後面可能取到值，redis的過時時間有延遲)
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        str = stringRedisTemplate.opsForValue().get("tesGetString");
        Assert.assertNull(str);
    }

    //注意：redisTemplate操做對象時對象須要實現序列化接口
    @Test
    public void testObject() {
        Person person = generatePerson();
        redisTemplate.opsForValue().set("testObject:" + person.getUsername(), person, 600);
    }

    @Test
    public void tesGetObject() {
        Person person = generatePerson();
        redisTemplate.opsForValue().set("tesGetObject:" + person.getUsername(), person);
        Person cachePerson = (Person) redisTemplate.opsForValue().get("tesGetObject:" + person.getUsername());
        Assert.assertEquals(person, cachePerson);
    }

    @Test
    public void tesDeleteCache() {
        stringRedisTemplate.opsForValue().set("tesDeleteCache", "123456");
        String cacheStr = stringRedisTemplate.opsForValue().get("tesDeleteCache");
        Assert.assertEquals("123456", cacheStr);

        stringRedisTemplate.delete("tesDeleteCache");
        String DeleteStr = stringRedisTemplate.opsForValue().get("tesDeleteCache");
        Assert.assertNull(DeleteStr);
    }

    //二者操做互不影響
    @Test
    public void testStrRedisTempAndRedisTemp(){
        Person person = generatePerson();
        //生成key爲：\xAC\xED\x00\x05t\x00\x04test
        redisTemplate.opsForValue().set("testDiff", person);
        //生稱key爲：test
        stringRedisTemplate.opsForValue().set("testDiff", "123456");

        String cacheStr = stringRedisTemplate.opsForValue().get("testDiff");
        Assert.assertEquals("123456", cacheStr);

        Person cachePerson = (Person) redisTemplate.opsForValue().get("testDiff");
        Assert.assertEquals(person, cachePerson);
    }
    
    private Person generatePerson() {
        Person person = new Person();
        person.setId(1L);
        person.setUsername("wangwu");
        person.setPassword("123456");
        return person;
    }
}

deploy

• update.sql:數據庫sql文件

CREATE DATABASE springboot_database;
USE springboot_database;

DROP TABLE IF EXISTS `user` ;

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `password` varchar(50) NOT NULL,
  `mobile` varchar(20) NOT NULL,
  `email` varchar(50) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

pom.xml

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- lombok相關start -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!-- lombok相關end -->

        <!-- mongodb相關start -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <!-- mongodb相關end -->

        <!-- redis相關start -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-redis</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <!-- redis相關end -->

        <!-- mybatis相關start -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!-- mybatis相關end -->

        <!-- mysql相關start -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- mysql相關end -->

        <!-- jpa相關start -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!-- jpa相關end -->
        
    </dependencies>