# AutoMapper

**Repository Path**: 85024610/AutoMapper

## Basic Information

- **Project Name**: AutoMapper
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2018-03-24
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# AutoMapper
## 拦截器
* 重新创建MappedStatement, 防止并发查询时返回映射结果类型出现错误
```
com.automapper.interceptor.AutoMapperCacheInterceptor
```
* 在ExecutorType.SIMPLE模式下替换原来的SimpleExecutor对象，实现批量入库操作。 注意：现在只支持批量update
```
com.automapper.interceptor.AutoMapperChangeExecutorTypeInterceptor
```
* 判断参数是null或集合是空集合拦截器
```
com.automapper.interceptor.AutoMapperCheckEmptyInterceptor
```
* 自动生成sql语句拦截器
```
com.automapper.interceptor.AutoMapperInterceptor
```

## Spring.xml配置
* 拦截器配置的内容

```
<context:annotation-config />
		<!-- AutoMapper资源文件扫描 -->
		<context:component-scan base-package="com.mybatis.plugin.automapper.repository" />
	
		<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
			<!-- AutoMapper的com.plugin.mybatis.**.repository注册, 注意：如果注册多个repository，需要用分号分隔 -->
			<property name="basePackage" value="com.visual.**.repository;com.mybatis.plugin.**.repository" />
			<property name="sqlSessionFactoryBeanName" value="myBatisSqlSessionFactory" />
			<property name="annotationClass" value="org.springframework.stereotype.Repository" /> 
		</bean>

		<bean id="myBatisSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
			<property name="dataSource" ref="ods-osp-stateDataSource" />        
        	<property name="mapperLocations" >
       			<list>
       				<value>classpath*:mapper/*Mapper.xml</value>
       				<!-- AutoMapper插件 Mapper.xml配置 -->
       				<value>classpath*:com/automapper/AutoMapper.xml</value>
        		</list> 
        	</property>
        
        	<!-- 配置Mybatis的插件plugin-->
	    	<property name="plugins">
	    		<array>
                    <bean id=”autoMapperCacheInterceptor” class="com.mybatis.plugin.automapper.interceptor.AutoMapperCacheInterceptor"></bean>
                    <bean id="autoMapperCheckEmptyInterceptor" class="com.mybatis.plugin.automapper.interceptor.AutoMapperCheckEmptyInterceptor"></bean>
	    			<bean id="autoInterceptor" class="com.mybatis.plugin.automapper.interceptor.AutoMapperInterceptor">
						<property name="properties">
							<value>
								isNullToDefaultValue=true
							</value>
						</property>
					</bean>
	    		</array> 
	    	</property>
	    </bean>
```

## Java Bean 注解配置

```
//对应数据表的表名
@Table(name="job_state_index")
public class JobStateIndex {

	@Id //主键，必须与@Column一起使用
	@Column(name="id") //字段名
	private Long id;
	
	@Column(name="order_sn")
	private String orderSn;
	
	@Column(name="index_num")
	private Integer indexNum;
	
	@Column(name="create_time")
	private Date createTime;

    @OneToMany  //级联查询
	private List<PackageOutboundDetail> packageOutboundDetails;
}


@Table(name="package_outbound_detail")
public class PackageOutboundDetail  {
		
	@JoinColumn(name="id") //关联父类字段
	@Column(name="header_id")
	private String headerId;
}

```
## 查询方法
* 查询使用 Criteria 进行查询条件的创建和组装，此查询借鉴hibernate设计，用过hibernate就知道怎样用
* Criteria提供以下方法进行查询条件的创建和组装

```
public Criteria add(Expression expression); //添加查询条件，目前where语句使用多个条件过滤条件只能用and
public Criteria setMaxResults(int maxResults); //获取查询最大记录数
public Criteria addAssociation(Class<?> clazz, String tableName, String alias); //设置级联查询对象
public void setFetchMode(FetchMode fetchMode); //级联查询fetch模式：ASSOCIATION_PAGE_BY_PARENT—父表分页然后再关联子表查询

```
* Restrictions提供多种查询条件

```
//等于（=） 查询条件
public static Expression eq(String columnName, Object value);
//大于（>） 查询条件
public static Expression gt(String columnName, Object value);
//大于等于（>=） 查询条件
public static Expression ge(String columnName, Object value);
//小于（<） 查询条件
public static Expression lt(String columnName, Object value);
//小于等于（<=） 查询条件
public static Expression le(String columnName, Object value);
//in 查询条件
public static Expression in(String columnName, List<Object> values);

```
* 创建一个Criteria 实例两种方式 :

```
①　 Criteria criteria = CriteriaFactory.createQuery(OspWmsJobStateIndex.class); // 第一个参数是查询对象
②　 Criteria criteria = CriteriaFactory.createQuery(OspWmsJobStateIndex.class, ’osp_wms_job_state_index’,’a’); // 第一个参数是查询对象，第二个参数是表名，第三个参数是表的别名

criteria.add(Restrictions.eq("order_sn", "order_sn500"));
criteria.add(Restrictions.ge("id", 500));
criteria.add(Restrictions.in("id", values));
criteria.setMaxResults(100);

然后调用AutoMapperRepository类的方法

```
* AutoMapperRepository类的方法

```
 /**
	 * 保存对象（不支持Map对象）
	 * @param obj
	 */
	public void insert(@Param("autoMapperParam") Object obj);
	
	/**
	 * 保存对象
	 * 表名会优先使用入场tableName, 当tableName为空或空字符串，将会使用对象@Table注解的name值
	 * @param obj
	 * @param tableName 表名
	 */
	public void insert(@Param("autoMapperParam") Object obj, @Param("tableName") String tableName);
	
	/**
	 * 保存对象
	 * 表名会优先使用入场tableName, 当tableName为空或空字符串，将会使用对象@Table注解的name值
	 * @param obj
	 * @param tableName 表名
	 * @param excludeCol 排查入库字段（对象@Column.name的值）
	 */
	public void insert(@Param("autoMapperParam") Object obj, @Param("tableName") String tableName, @Param("excludeCol") List<String> excludeCol);
	
	/**
	 * 更新操作（不支持Map，List对象）
	 * @param obj
	 */
	public void update(@Param("autoMapperParam") Object obj);
	
	/**
	 * 更新操作（不支持Map，List对象）
	 * 表名会优先使用入场tableName, 当tableName为空或空字符串，将会使用对象@Table注解的name值
	 * @param obj
	 * @param tableName 表名
	 */
	public void update(@Param("autoMapperParam") Object obj, @Param("tableName") String tableName);
	
	/**
	 * 更新操作（不支持Map，List对象）
	 * 表名会优先使用入场tableName, 当tableName为空或空字符串，将会使用对象@Table注解的name值
	 * @param obj
	 * @param tableName 表名
	 * @param excludeCol 排查更新字段（对象@Column.name的值）
	 */
	public void update(@Param("autoMapperParam") Object obj, @Param("tableName") String tableName, @Param("excludeCol") List<String> excludeCol);
	
	/**
	 * 根据对象@Id注解删除数据（不支持Map对象）
	 * @param obj
	 */
	public void delete(@Param("autoMapperParam") Object obj);
	
	/**
	 * 根据对象@Id注解删除数据（不支持Map对象）
	 * 表名会优先使用入场tableName, 当tableName为空或空字符串，将会使用对象@Table注解的name值
	 * @param obj
	 * @param tableName 表名
	 */
	public void delete(@Param("autoMapperParam") Object obj, @Param("tableName") String tableName);
	
	/**
	 * 保存对象（不支持Map对象）
	 * 并将生成的主键赋值给@Id的属性
	 * @param obj
	 */
	public void persistent(@Param("autoMapperParam") Object obj);
	
	/**
	 * 保存对象（不支持Map对象）
	 * 并将生成的主键赋值给@Id的属性
	 * 表名会优先使用入场tableName, 当tableName为空或空字符串，将会使用对象@Table注解的name值
	 * @param obj
	 * @param tableName 表名
	 */
	public void persistent(@Param("autoMapperParam") Object obj, @Param("tableName") String tableName);
	
	/**
	 * 保存对象（不支持Map对象）
	 * 并将生成的主键赋值给@Id的属性
	 * 表名会优先使用入场tableName, 当tableName为空或空字符串，将会使用对象@Table注解的name值
	 * @param obj
	 * @param tableName 表名
	 * @param excludeCol 排查更新字段（对象@Column.name的值）
	 */
	public void persistent(@Param("autoMapperParam") Object obj, @Param("tableName") String tableName, @Param("excludeCol") List<String> excludeCol);
	
	/**
	 * 查询方法
	 * @param query
	 * @return
	 */
	public <T> List<T> select(@Param("autoMapperParam") Criteria criteria); 

```
* Annotation使用说明
    * @Column 注解：
        1.	name：(可选)数据库字段名，但没有定义name的值时使用对象的变量名
        2.	nullable：(可选)该字段是否为空，默认值：true