@Data
@NoArgsConstructor
@AllArgsConstructor
@Table(name="tabple_emp")
public class Employee {
    private Integer empId;
    private String empName;
    private Double empSalary;
    private Integer empAge;
}

/**
* 具体操作数据库的 Mapper 接口，需要继承通用 Mapper 提供的核心接口:Mapper<Employee>
* 泛型类型就是实体类的类型 
*/
public interface EmployeeMapper extends Mapper<Employee> {
}

@Service
public class EmployeeService {

    @Autowired
    private EmployeeMapper employeeMapper;

    public Employee getOne(Employee employeeQueryCondition) {
        return employeeMapper.selectOne(employeeQueryCondition);
    }
}

public class EmployeeMapperTest extends Object {
    private ApplicationContext iocContainer = new ClassPathXmlApplicationContext("spring-context.xml");
    private EmployeeService employeeService = iocContainer.getBean(EmployeeService.class);

    @Test
    public void selectOne() {
        // 1. 创建封装查询条件的实体类对象
        Employee employeeQueryCondition = new Employee(null, "bob", 5560.11, null);
        // 2. 执行可查询条件
        Employee employeeQueryResult =employeeService.getOne(employeeQueryCondition);
        System.out.println(employeeQueryResult);
    }
}

@Data
@Table(name="tabple_emp")
public class Employee {
    private Integer empId;
    private String empName;
    private Double empSalary;
    private Integer empAge;
}

@Column(name="emp_salary_apple")
private Double empSalary;

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer empId;

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY,
                generator = "select SEQ_ID.nextval from dual")
private Integer empId;

@Transient
private String otherThings; //非数据库表中字段

//目标:WHERE (emp_salary>? AND emp_age<?) OR (emp_salary<? AND emp_age>?) 
//1.创建 Example 对象
Example example = new Example(Employee.class);
//***********************
//i.设置排序信息 
example.orderBy("empSalary").asc().orderBy("empAge").desc();
//ii.设置“去重” 
example.setDistinct(true);
//iii.设置 select 字段 
example.selectProperties("empName","empSalary");
//***********************
//2.通过 Example 对象创建 Criteria 对象
Criteria criteria01 = example.createCriteria(); 
Criteria criteria02 = example.createCriteria();
//3.在两个 Criteria 对象中分别设置查询条件 //property 参数:实体类的属性名
//value 参数:实体类的属性值
criteria01.andGreaterThan("empSalary", 3000).andLessThan("empAge", 25);
criteria02.andLessThan("empSalary", 5000) .andGreaterThan("empAge", 30);
//4.使用 OR 关键词组装两个 Criteria 对象 
example.or(criteria02);
//5.执行查询
List<Employee> empList = employeeService.getEmpListByExample(example);
for (Employee employee : empList) { 
  System.out.println(employee);
}

public interface MyMapper<T> 
		extends SelectAllMapper<T>,SelectByExampleMapper<T> {

}

public interface EmployeeMapper extends MyMapper<Employee> {}

package cn.silince.mapper.mine_mappers;
public interface MyBatchUpdateMapper<T> {

    @UpdateProvider(type=MyBatchUpdateProvider.class,method = "dynamicSQL")
    void batchUpdate(List<T> list);
}

package cn.silince.mapper.mine_mappers;
public interface MyMapper<T> 
		extends SelectAllMapper<T>,
		SelectByExampleMapper<T>,
		MyBatchUpdateMapper<T> {
}

package cn.silince.mapper.mine_mappers;

/**
 * @program: Pro03MapperOfMine
 * @description:
 * @author: Silince
 * @create: 2020-10-25 22:29
 **/
public class MyBatchUpdateProvider extends MapperTemplate {

    public MyBatchUpdateProvider(Class<?> mapperClass, MapperHelper mapperHelper) {
        super(mapperClass, mapperHelper);
    }

    /*
    <foreach collection="list" item="record" separator=";" >
        UPDATE tabple_emp
        <set>
            emp_name=#{record.empName},
            emp_age=#{record.empAge},
            emp_salary=#{record.empSalary},
        </set>
        where emp_id=#{record.empId}
    </foreach>
 */
    public String batchUpdate(MappedStatement statement){
        // 1创建StringBuilder用于拼接SQL语句的各个组成部分
        StringBuilder builder = new StringBuilder();

        // 2拼接foreach标签
        builder.append("<foreach collection=\"list\" item=\"record\" separator=\";\" >");

        // 3获取实体类对应的Class对象
        Class<?> entityClass = super.getEntityClass(statement);

        // 4 获取实体类在数据库中对应的表名
        String tableName = super.tableName(entityClass);
        // 5 生成update子句
        String updateClause = SqlHelper.updateTable(entityClass, tableName);

        builder.append(updateClause);

        builder.append("<set>");

        // 6 获取所有字段的信息
        Set<EntityColumn> columns = EntityHelper.getColumns(entityClass);

        String idColumn = null;
        String idHolder = null;

        for (EntityColumn entityColumn : columns) {
            // 7 判断主键
            boolean isPrimaryKey = entityColumn.isId();
            if (isPrimaryKey){
                // 8 缓存主键的字段名和字段值
                idColumn = entityColumn.getColumn();
                // 返回格式如:#{record.age,jdbcType=NUMERIC,typeHandler=MyTypeHandler}
                idHolder = entityColumn.getColumnHolder("record");
            }else {
                 // 9使用非主键字段拼接SET子句
                String column = entityColumn.getColumn();
                String columnHolder = entityColumn.getColumnHolder("record");

                builder.append(column).append("=").append(columnHolder).append(",");
            }
        }

        builder.append("</set>");

        // 10 使用前面缓存的主键名、主键值拼接where子句
        builder.append("where  ").append(idColumn).append("=").append(idHolder);

        builder.append("</foreach>");

        // 11 将拼接好的字符串返回
        return builder.toString();
    }

}

package cn.silince.mapper.services;

@Service
public class EmployeeService {
	
	@Autowired
	private EmployeeMapper employeeMapper;

	public List<Employee> getAll() {
		return employeeMapper.selectAll();
	}

	public void batchUpdateEmp(List<Employee> empList){
		employeeMapper.batchUpdate(empList);
	}
}

@CacheNamespace
public interface EmployeeMapper extends MyMapper<Employee> {
}

public interface TypeHandler<T> {
	//将 parameter 设置到 ps 对象中，位置是 i
  //在这个方法中将 parameter 转换为字符串
	void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;

  //根据列名从 ResultSet 中获取数据，通常是字符串形式 
  //将字符串还原为 Java 对象，以 T 类型返回
	T getResult(ResultSet rs, String columnName) throws SQLException;
	T getResult(ResultSet rs, int columnIndex) throws SQLException;
	T getResult(CallableStatement cs, int columnIndex) throws SQLException; 
}

//将 parameter 对象转换为字符串存入到 ps 对象的 i 位置 
public abstract void setNonNullParameter(
	PreparedStatement ps,
	int i,
	T parameter,
	JdbcType jdbcType) throws SQLException;
//从结果集中获取数据库对应查询结果 
//将字符串还原为原始的 T 类型对象 
public abstract T getNullableResult(ResultSet rs,String columnName) throws SQLException;
public abstract T getNullableResult( ResultSet rs,int columnIndex) throws SQLException;
public abstract T getNullableResult( CallableStatement cs,int columnIndex) throws SQLException;

public class AddressTypeHandler extends BaseTypeHandler<Address> {

	@Override
	public void setNonNullParameter(PreparedStatement ps, int i, Address address, JdbcType jdbcType)
			throws SQLException {
		
		//1.对address对象进行验证
		if(address == null) {
			return ;
		}
		
		//2.从address对象中取出具体数据
		String province = address.getProvince();
		String city = address.getCity();
		String street = address.getStreet();
		
		//3.拼装成一个字符串
		//规则：各个值之间使用“,”分开
		StringBuilder builder = new StringBuilder();
		builder
			.append(province)
			.append(",")
			.append(city)
			.append(",")
			.append(street);
		
		String parameterValue = builder.toString();
		
		//4.设置参数
		ps.setString(i, parameterValue);
		
	}

	@Override
	public Address getNullableResult(ResultSet rs, String columnName) throws SQLException {
		
		//1.根据字段名从rs对象中获取字段值
		String columnValue = rs.getString(columnName);
		
		//2.验证columnValue是否有效
		if(columnValue == null || columnValue.length() == 0 || !columnValue.contains(",")) {
			return null;
		}
		
		//3.根据“,”对columnValue进行拆分
		String[] split = columnValue.split(",");
		
		//4.从拆分结果数组中获取Address需要的具体数据
		String province = split[0];
		String city = split[1];
		String street = split[2];
		
		//5.根据具体对象组装一个Address对象
		Address address = new Address(province, city, street);
		
		return address;
	}

	@Override
	public Address getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
		//1.根据字段名从rs对象中获取字段值
		String columnValue = rs.getString(columnIndex);
		
		//2.验证columnValue是否有效
		if(columnValue == null || columnValue.length() == 0 || !columnValue.contains(",")) {
			return null;
		}
		
		//3.根据“,”对columnValue进行拆分
		String[] split = columnValue.split(",");
		
		//4.从拆分结果数组中获取Address需要的具体数据
		String province = split[0];
		String city = split[1];
		String street = split[2];
		
		//5.根据具体对象组装一个Address对象
		Address address = new Address(province, city, street);
		
		return address;
	}

	@Override
	public Address getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
		//1.根据字段名从rs对象中获取字段值
		String columnValue = cs.getString(columnIndex);
		
		//2.验证columnValue是否有效
		if(columnValue == null || columnValue.length() == 0 || !columnValue.contains(",")) {
			return null;
		}
		
		//3.根据“,”对columnValue进行拆分
		String[] split = columnValue.split(",");
		
		//4.从拆分结果数组中获取Address需要的具体数据
		String province = split[0];
		String city = split[1];
		String street = split[2];
		
		//5.根据具体对象组装一个Address对象
		Address address = new Address(province, city, street);
		
		return address;
	}

}

@ColumnType(typeHandler= AddressTypeHandler.class)
private Address address;

@Column
private Address address;

@Column
private SeasonEnum season;