import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

@Data // 自动生成get、set方法
@ConfigurationProperties(prefix = "student") // 绑定配置文件的属性
public class Student {
    private String name;
    private String major;
}

@EnableConfigurationProperties(Student.class) //指定Student类为bean，并绑定属性
@SpringBootApplication
public class Springboot08ConfigurationApplication {
    
    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(Springboot08ConfigurationApplication.class, args);
        System.out.println("-------封装实体类----------");
        Student student = run.getBean(Student.class);
        System.out.println(student.getName());
        System.out.println(student.getMajor());
        System.out.println("-----------------");
    }
}

@Bean
@ConfigurationProperties(prefix = "source")
public DruidDataSource dataSource(){
    DruidDataSource source = new DruidDataSource();
    return source;
}

@SpringBootApplication
public class Springboot08ConfigurationApplication {
    @Bean
    @ConfigurationProperties(prefix = "source")
    public DruidDataSource dataSource(){
        DruidDataSource source = new DruidDataSource();
        return source;
    }

    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(Springboot08ConfigurationApplication.class, args);

        DruidDataSource bean = run.getBean(DruidDataSource.class);
        System.out.println("--------第三方Bean---------");
        System.out.println(bean.getDriverClassName());
        System.out.println(bean.getUsername());
        System.out.println(bean.getPassword());
        System.out.println("-----------------");
    }
}

@Bean
@ConfigurationProperties(prefix = "dataSource")
public DruidDataSource datasource(){
    DruidDataSource ds = new DruidDataSource();
    return ds;
}

@Component
@Data
@ConfigurationProperties(prefix = "servers")
public class ServerConfig {
    private String ipAddress;
}

@Component
@Data
@ConfigurationProperties(prefix = "servers")
public class ServerConfig {
    @DurationUnit(ChronoUnit.HOURS)
    private Duration serverTimeOut;
    @DataSizeUnit(DataUnit.MEGABYTES)
    private DataSize dataSize;
}

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;

//@Component
@Data // 自动生成get、set方法
@ConfigurationProperties(prefix = "student") // 绑定配置文件的属性
@Validated
public class Student {
    private String name;
    private String major;
    @Max(value = 120,message = "最大值不能超过120")
    @Min(value = 0,message = "最小值不能小于0")
    private Integer age;
}

import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest(classes = Application.class)
class ApplicationTests {
    
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest(classes = Application.class)
class ApplicationTests {
    @Value("${hikki.username}")
    private String username;

    @Test
    public void test(){
        System.out.println(username);
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest(classes = Application.class,properties = "hikki.username='lisi'")
class ApplicationTests {
    @Value("${hikki.username}")
    private String username;

    @Test
    public void test(){
        System.out.println(username);
    }
}

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

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest(classes = Application.class,properties = "hikki.username='lisi'",args = "--hikki.username='wangwu'")
class ApplicationTests {
    @Value("${hikki.username}")
    private String username;

    @Test
    public void test(){
        System.out.println(username);
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Import;
import site.hikki.config.MsgConfig;

@SpringBootTest(classes = Application.class)
@Import({MsgConfig.class})
class ApplicationTests {
    @Autowired
    private String msg;

    @Test
    void testConfiguration() {
        System.out.println(msg);
    }
}

@SpringBootTest(classes = Application.class,webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ApplicationTests {
    
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

@AutoConfigureMockMvc //开启虚拟MVC调用
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class WebTest {

}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

@AutoConfigureMockMvc //开启虚拟MVC调用
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class WebTest {
    @Test
    public void testWeb(@Autowired MockMvc mvc){

    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;

@AutoConfigureMockMvc //开启虚拟MVC调用
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class WebTest {

    @Test
    void testWeb(@Autowired MockMvc mvc) throws Exception {
        //http://localhost:8080/hello
        //创建虚拟请求，当前访问/hello
        MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/hello");
        //执行对应的请求
        mvc.perform(builder);
    }
}

@Test
void testGetById(@Autowired MockMvc mvc) throws Exception {
    MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/hello");
    ResultActions action = mvc.perform(builder);

    StatusResultMatchers status = MockMvcResultMatchers.status();
    ResultMatcher ok = status.isOk();
    action.andExpect(ok);

    HeaderResultMatchers header = MockMvcResultMatchers.header();
    ResultMatcher contentType = header.string("Content-Type", "application/json");
    action.andExpect(contentType);

    ContentResultMatchers content = MockMvcResultMatchers.content();
    ResultMatcher result = content.json("{}"); //因为我返回的格式不是json格式，这里不做测试
    action.andExpect(result);
}

@Transactional
@Rollback(true)
@SpringBootTest
public class RollbackTest {

    @Autowired
    private BookDao bookDao;

    /**
     * 不提交事务，默认不修改数据库
     */
    @Test
    public void testDelBook(){
        int i = bookDao.delBookById(8);
        System.out.println(i);
    }

    /**
     * 提交事务，即对数据库进行修改
     */
    @Test
    @Rollback(value = false)
    public void testAddBook(){
        Book book = new Book();
        book.setName("标准日本语");
        book.setDescription("这是一本日语初学者常用的课本");
        book.setType("外语");
        int i = bookDao.addBook(book);
        System.out.println(i);
    }
}

@Repository
public class BookDaoTemplate {
    @Autowired
    JdbcTemplate jdbcTemplate;
    
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import site.hikki.pojo.Book;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

/**
 * @author : 小码同学
 * Date: 2023/5/10 17:30
 * 小码博客 ：https://blog.hikki.site
 * 小码同学公众号 ：小码同学
 */

@Repository
public class BookDaoTemplate {
    @Autowired
    JdbcTemplate jdbcTemplate;

    /**
     * 不使用实体类封装，自定义键值对封装
     * @return
     */
    public List<Map<String,Object>> findBook(){
        String sql = "select * from tb_book";
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
        return maps;
    }

    public List<Book> find(){
        String sql = "select * from tb_book";
        RowMapper<Book> rm = new RowMapper<Book>() {
            @Override
            public Book mapRow(ResultSet rs, int rowNum) throws SQLException {
                Book temp = new Book();
                temp.setId(rs.getInt("id"));
                temp.setName(rs.getString("name"));
                temp.setType(rs.getString("type"));
                temp.setDescription(rs.getString("description"));
                return temp;
            }
        };
        List<Book> list = jdbcTemplate.query(sql, rm);
        return list;
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import site.hikki.dao.BookDaoTemplate;
import site.hikki.pojo.Book;
import java.util.List;
import java.util.Map;

/**
 * @author : 小码同学
 * Date: 2023/5/9 22:18
 * 小码博客 ：https://blog.hikki.site
 * 小码同学公众号 ：小码同学
 */
@SpringBootTest(classes = Application.class)
public class JdbcTemplateTest {
    @Autowired
    private BookDaoTemplate bookDaoTemplate;

    @Test
    void testJdbcTemplate(){
        List<Map<String, Object>> book = bookDaoTemplate.findBook();
        System.out.println(book);
    }

    @Test
    void findJdbcTemplate(){
        List<Book> books = bookDaoTemplate.find();
        System.out.println(books);
    }
}

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity(name = "tb_student") // 对应表名
public class Student {

    @Id // 表主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) // ID自增
    private Integer num;
    private Integer age;
    private String name;
    private String major;
    // 自行添加get set toString方法
}

import org.springframework.data.jpa.repository.JpaRepository;
import site.hikki.domain.Student;

public interface StudentRepositoty extends JpaRepository<Student,Integer> {

}

findByNameLike(String name)
findByName(String name)

@NoRepositoryBean 
public interface CrudRepository<T, ID> extends Repository<T, ID> { 
    <S extends T> S save(S entity); //保存 
    <S extends T> Iterable<S> save(Iterable<S> entities);  
    T findOne(ID id); //根据id查询一个对象，返回对象本身或null  
    Iterable<T> findAll(); //查询所有的对象 
    Iterable<T> findAll(Iterable<ID> ids); //据id列表查所有对象  
    boolean exists(ID id); //根据id 判断对象是否存在
    long count(); //计算对象的总个数 
    void delete(ID id); //根据id 删除 
    void delete(T entity); //删除一个对象
    void delete(Iterable<? extendsT> entities); //批量删除集合  
    void deleteAll(); //删除所有（后台执行时，一条一条删除）
}

@NoRepositoryBean 
public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {
       Iterable<T> findAll(Sort sort);// 仅排序 
        Page<T>findAll(Pageable pageable);//分页和排序 
} 

@NoRepositoryBean
public interface JpaRepository<T,ID extendsSerializable> extends PagingAndSortingRepository<T,ID>,QueryByExampleExecutor<T> {  
   List<T>findAll(); //查询所有对象，返回List
   List<T>findAll(Sort sort); //查所有对象并排序，返回List
   List<T>findAll(Iterable<ID> ids); 
   void flush(); //强制缓存与数据库同步
   <S extends T> List<S> save(Iterable<S> entities); //批量保存，并返回对
	List<S extends T> S saveAndFlush(S entity);//保存并强制同步数据
    //批量删集合对象(后台执行时，生成一条语句，多个or条件）
    void deleteInBatch(Iterable<T> entities);
    //删除所有（执行一条语句，如：delete from user）
    void deleteAllInBatch();  
    //根据id 查询一个对象，返回对象的引用(区别于findOne)。当对象不存时，返回引用不是null，但各个属性值是null
    T getOne(ID id); 
    //根据实例查询
    <S extends T> List<S> findAll(Example<S> example); 
    //根据实例查询并排序。
    <S extends T> List<S> findAll(Example<S> example, Sort sort);
}

import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.transaction.annotation.Transactional;
import site.hikki.domain.Student;
import java.util.List;

public interface StudentRepositoty extends JpaRepository<Student,Integer> {
    /**
     * Jpa自带了一部分的封装好的常用方法，我们可以直接使用。
     * 如果封装好的方法不能满足你的需求，你可以根据自己的需求来编写SQL语句，比如下面是自定义的方法
     */

    /**
     * 使用形参的方式有两种，一种是用 :形参名
     * 另一种是使用数字表示第几位参数 :?n
     */
    @Query("select s from tb_student s where s.num=:num") //使用参数命
//    @Query("select s from tb_student s where s.num=?1") // 使用占位符
    List<Student> getStudentByNum(Integer num);

    /**
     * 查询全部数据，使用分页查询
     * Pageable 是表示使用分页接收结果，具体可以查看测试方法
     */
    @Query("select s from tb_student s") //使用参数命
    List<Student> getStudentPage(Pageable pageable);

    /**
     * nativeQuery = true 表示开启原生SQL,不需要像上面一样使用表别名
     */
    @Query(value = "select * from tb_student",nativeQuery = true)
    List<Student> getStudentPage2(Pageable pageable);
}

/**
 * ?n 表示占位符，使用该方法中的第几个参数
 * 如 name = ?2 使用形参中的 name 参数
 *  num = ?1 使用形参中的 num
 */
@Transactional
@Modifying
@Query(value = "update tb_student set name = ?2 where num = ?1",nativeQuery = true)
int updateStudentByNum(Integer num,String name);

/**
 * 根据num删除学生
 * 因为是对数据进行改动，必须添加Transactional和Modifying注解
 */
@Transactional
@Modifying
@Query(value = "delete from tb_student where num = ?1",nativeQuery = true)
int delStudentByNum(Integer num);

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
import site.hikki.domain.Student;
import site.hikki.repository.StudentRepositoty;

import java.util.List;

@SpringBootTest(classes = Application.class)
class ApplicationTests {
    @Autowired
    private StudentRepositoty studentRepositoty;

    @Test
    public void find() {
        List<Student> all = studentRepositoty.findAll();
        System.out.println(all);
    }

    @Test
    public void getStudentByNum(){
        List<Student> page = studentRepositoty.getStudentByNum(3);
        System.out.println(page);
    }

    @Test
    public void getStudentPage(){
        PageRequest request = PageRequest.of(1, 2);// 查询第一页，每页2条数据
        List<Student> studentPage = studentRepositoty.getStudentPage(request);
        for (Student s :studentPage) {
            System.out.println(s);
        }
    }

    @Test
    public void getStudentPage2(){
        PageRequest request = PageRequest.of(1, 2);// 查询第一页，每页2条数据
        List<Student> studentPage = studentRepositoty.getStudentPage2(request);
        for (Student s :studentPage) {
            System.out.println(s);
        }
    }

    /**
     * 修改学生
     */
    @Test
    public void updateStudentByNum(){
        int i = studentRepositoty.updateStudentByNum(12, "小黑子");
        System.out.println(i);
    }

    /**
     * 删除学生
     */
    @Test
    public void delStudentByNum(){
        int i = studentRepositoty.delStudentByNum(12);
        System.out.println(i);
    }
}

import javax.persistence.*;
import java.util.List;

@Entity(name = "tb_dept") // 绑定数据表
public class Dept {
    @Id // 表示该属性是主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) // ID自增
    private Integer deptId;
    private String deptName;

    @OneToMany(
            mappedBy = "dept", //定义在关系的被维护端，指向关系的维护端；@ManyToOne不存在该属性，只有@OneToOne，@OneToMany，@ManyToMany上才有该属性。
            targetEntity = Major.class, // 关联类的类型，默认是该成员属性对应的类类型
            fetch = FetchType.EAGER //急加载，加载一个实体时，会立即从数据库中加载
    )
    private List<Major> majors;


    @Override
    public String toString() {
        return "Dept{" +
                "deptId=" + deptId +
                ", deptName='" + deptName + '\'' +
                ", majorList=" + majors +
                '}';
    }

    public Integer getDeptId() {
        return deptId;
    }

    public void setDeptId(Integer deptId) {
        this.deptId = deptId;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

    public List<Major> getMajorList() {
        return majors;
    }

    public void setMajorList(List<Major> majorList) {
        this.majors = majorList;
    }
}

import com.fasterxml.jackson.annotation.JsonIgnore;
import javax.persistence.*;
import java.io.Serializable;

@Entity(name = "tb_major") // 绑定数据表
public class Major implements Serializable {
    @Id // 表示该属性是主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) // ID自增
    private Integer majorId;
    private String majorName;
    private Integer tuition;

    @ManyToOne(
            fetch = FetchType.EAGER, //急加载，加载一个实体时，会立即从数据库中加载
            targetEntity = Dept.class // 关联类的类型，默认是该成员属性对应的类类型
    )
    @JoinColumn(
            name = "deptId",
            referencedColumnName = "deptId"
    )
    @JsonIgnore
    private Dept dept;


    @Override
    public String toString() {
        return "Major{" +
                "majorId=" + majorId +
                ", majorName='" + majorName + '\'' +
                ", tuition=" + tuition +
                '}';
    }


    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public Integer getMajorId() {
        return majorId;
    }

    public void setMajorId(Integer majorId) {
        this.majorId = majorId;
    }

    public String getMajorName() {
        return majorName;
    }

    public void setMajorName(String majorName) {
        this.majorName = majorName;
    }

    public Integer getTuition() {
        return tuition;
    }

    public void setTuition(Integer tuition) {
        this.tuition = tuition;
    }

    public Dept getDeptId() {
        return dept;
    }

    public void setDeptId(Dept deptId) {
        this.dept = deptId;
    }
}

import org.springframework.data.jpa.repository.JpaRepository;
import site.hikki.domain.Major;
import java.util.List;

public interface MajorRepository extends JpaRepository<Major,Integer> {
    List<Major> findByMajorNameContains(String majorName);

}

import org.springframework.data.jpa.repository.JpaRepository;
import site.hikki.domain.Dept;

public interface DeptRepository extends JpaRepository<Dept,Integer> {
    Dept findByDeptId(Integer id);
}

import site.hikki.domain.Dept;
import site.hikki.domain.Major;
import java.util.List;

public interface DeptAndMajorService {
    Dept findDeptWithMajor(Integer id);
    List<Major> findByMajorNameContains(String majorName);
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import site.hikki.domain.Dept;
import site.hikki.domain.Major;
import site.hikki.repository.DeptRepository;
import site.hikki.repository.MajorRepository;
import site.hikki.service.DeptAndMajorService;
import java.util.List;

@Service
public class DeptAndMajorServiceImpl implements DeptAndMajorService {
    @Autowired
    private DeptRepository deptRepository;

    @Autowired
    private MajorRepository majorRepository;

    @Override
    public Dept findDeptWithMajor(Integer id) {
        return deptRepository.findByDeptId(id);
    }

    @Override
    public List<Major> findByMajorNameContains(String majorName) {
        return majorRepository.findByMajorNameContains(majorName);
    }
}

package site.hikki;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import site.hikki.domain.*;
import site.hikki.service.DeptAndMajorService;

import java.util.List;

/**
 * @author : 小码同学
 * Date: 2023/5/22 1:21
 * 小码博客 ：https://blog.hikki.site
 * 小码同学公众号 ：小码同学
 */
@SpringBootTest(classes = Application.class)
public class OneToManyTest {

    @Autowired
    DeptAndMajorService deptAndMajorService;


    /**
     * 根据专业名称(major_name，模糊查询)查询；
     */
    @Test
    public void MajorByMajorName(){
        List<Major> contains = deptAndMajorService.findByMajorNameContains("工程");
        for (Major m :contains) {
            System.out.println(m);
        }
    }
    
    /**
     * 根据系编号(dept_id)查询
     */
    @Test
    public void findDeptWithMajor(){
        Dept major = deptAndMajorService.findDeptWithMajor(407);
        System.out.println(major);
    }
}