# simple-orm

**Repository Path**: haopeng/simple-orm

## Basic Information

- **Project Name**: simple-orm
- **Description**: 基于 spring-jdbc的 简易rom框架（支持多数据源）
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 4
- **Forks**: 4
- **Created**: 2017-04-07
- **Last Updated**: 2022-03-24

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

#基于spring-jdbc 和 javax.persistence 注解的简易ORM框架,支持多数据源（目前仅支持 mysql）

通过简单的常规的spring的配置就可以轻松实现，对代码无侵入，整个个jar包不到 30多K，包括对数据常用的所有操作，对于特殊业务可以灵活扩展；

- 通过maven引用此包
```
<dependency>
    <groupId>net.oschina.haopeng</groupId>
    <artifactId>simple-orm</artifactId>
    <version>v1.9</version>
</dependency>
```

- 只需要配置 datasource 和 jdbcTemplate 见下面配置：
```
<context:property-placeholder
        ignore-unresolvable="true" location="classpath:database.properties" />

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" // 配置数据源 这里使用了druid（或 c3p0）
        init-method="init" destroy-method="close">
        <property name="url" value="${nb.data.url}"/>
        <property name="username" value="${nb.data.user}" />
        <property name="password" value="${nb.data.pwd}" />

        <property name="filters" value="log4j" />
        <property name="proxyFilters">
            <list>
                <ref bean="stat-filter" />
            </list>
        </property>
        <property name="maxActive" value="20" />
        <property name="initialSize" value="1" />
        <property name="maxWait" value="60000" />
        <property name="minIdle" value="1" />

        <property name="timeBetweenEvictionRunsMillis" value="60000" />
        <property name="minEvictableIdleTimeMillis" value="300000" />

        <property name="testWhileIdle" value="true" />
        <property name="testOnBorrow" value="false" />
        <property name="testOnReturn" value="false" />

        <property name="poolPreparedStatements" value="true" />
        <property name="maxOpenPreparedStatements" value="20" />
    </bean>

    <bean id="stat-filter" class="com.alibaba.druid.filter.stat.StatFilter">
        <property name="slowSqlMillis" value="10000" />
        <property name="logSlowSql" value="true" />
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> //配置jdbcTemplate
        <property name="dataSource" ref="dataSource"></property>
    </bean>
     // 用于配置 spring的扫描器 加载bean到容器中
    <context:component-scan base-package="com.simple.orm.test"></context:component-scan> 
```
- 自定义dao 数据操作层 只需要继承 BaseDaoAdapter 抽象类 就可以继承基础的操作

```
@Repository //通过spring注解自动加载到 bean 容器中
public class SysUserDao extends BaseDaoAdapter<SysUser>{
    // 实现对当前dao操作的扩展
   //根据名称模糊查询（样例）
   public List<SysUser> like(String name) throws SQLException {
      return getQuery().likeProperty("userName", "hao").list();
   }

    // 更新用户名称
    public Integer updateUserName(String userName,int userId) throws SQLException {
	return getUpdater().equalProperty("userId", userId).setProperty("userName", userName).update();
    }

}
```

- 自定义 service 业务层 只需要继承 BaseServiceImpl 抽象类 就可以轻松继承基本业务的操作

```
//自定义业务接口
public interface SysUserService extends BaseService<SysUser>{
    //用于业务接口的扩展
}

//自定义业务实现类
@Service //通过spring注解自动加载到 bean 容器中
public class SysUserServiceImpl extends BaseServiceImpl<SysUser> implements SysUserService{
    //用于对业操作的扩展
}
```

- 使用方法

```
//自定义性别枚举（下面会用到）
public enum Sex {

    MALE,FEMALE
}

//定义数据映射实体类

@Table(name="sys_user") // 设置对应的表名
@TargetDataSource(name="hueDataSource") //如果需要支持多数据源，添加此注解
public class SysUser implements Serializable {
    
    @Id //设置为主键值
    @Column(name="id") //设置数据库中对应的字段名
    private Long userId;

    @Column(name="status") // 设置数据库中对应的字段名
    private boolean status;
    
    @Column(name="user_name")
    private String userName;
    
    @OrderBy(value="DESC") //设置默认的排序字段,在查询时如果没有设置就按默认的排序方式查询；
    @Column(name="create_date")
    private Date createDate;

    @Column(name="sex")
    @Enumerated(EnumType.ORDINAL) //此处为枚举属性；@Enumerated(EnumType.STRING)：以枚举的名称存储；@Enumerated(EnumType.ORDINAL)：以枚举的ORDINAL存储；（如果不写默认按名称存储）
    private Sex sex;

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public boolean isStatus() {
        return status;
    }

    public void setStatus(boolean status) {
        this.status = status;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public Sex getSex() {
        return sex;
    }

    public void setSex(Sex sex) {
        this.sex = sex;
    }
}



实际的操作：


DAO(数据操作层demo)：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:beans.xml"})
public class DaoTest {

    @Autowired
    SysUserDao sysUserDao;

  //指定查询字段
  @Test
    public void testSelect() {
        try {
            print(sysUserDao.select("userId", "userName","createDate","sex").setOrderBy("createDate","asc").query());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
      // 查询单条数据 
    @Test
    public void testFind(){
        try {
            System.out.println(sysUserDao.find(2));
        } catch (DataAccessException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //模糊查询
    @Test
    public void like() throws SQLException {
    	print(sysUserDao.like("h"));
    }
    
    // 保存数据   
    @Test
    public void testSave(){
        try {
            SysUser s=new SysUser();
            s.setSex(Sex.FEMALE);
            s.setCreateDate(new Date());
            s.setUserName("pegyou");
            System.err.println(sysUserDao.insert(s).getUserId());
        } catch (DataAccessException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
   
    // 统计数据
    @Test
    public void testCount(){
        try {
            SysUser s=new SysUser();
            s.setUserName("pegyou");
            System.err.println(sysUserDao.count(s));
        } catch (DataAccessException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
   
     //更新数据库中的数据
    @Test
    public void testUpdate(){
        try {
            sysUserDao.update("userName", "我的测试", "userName", "pegyou");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 设置配置 并查询多条数据
    @Test
    public void testQueryAll(){
        try {
            print(sysUserDao.query());
            System.out.println();
            print(sysUserDao.setOrderBy("userId", "desc").query());
            System.out.println();
            print(sysUserDao.query());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    
    @Test
    public void  testCountAll(){
        try {
            System.out.println(sysUserDao.count());
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    
    // 根据ID主键值删除
    @Test
    public void deleteById(){
        try {
            System.out.println(sysUserDao.deleteById(12));
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    //根据bean属性删除
    @Test
    public void delete(){
        try {
            SysUser sysUser=new SysUser();
            sysUser.setUserName("我的测试");
            System.out.println(sysUserDao.delete(sysUser));
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    
    public void print(List<SysUser> ls){
        for(SysUser sysUser:ls){
            System.out.println(sysUser.getUserId()+" "+sysUser.getUserName()+" "+sysUser.getSex()+" "+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(sysUser.getCreateDate()));
        }
    }
    
}


Service(业务操作层实现demo)：


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:beans.xml"})
public class ServiceTest {

	@Autowired
	SysUserService sysUserService;
	
      @Test
    public void testSelect(){
        try {
            print(sysUserService.select("userId","userName","sex").query());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

	@Test
	public void testFind(){
		try {
			print(sysUserService.find(2));
		} catch (DataAccessException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	@Test
	public void update(){
		try {
			sysUserService.update("userName","我的测试", "userName", "pegyou");
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	@Test
	public void testQuery(){
		try {
			SysUser m=new SysUser();
			m.setStatus(false);
			print(sysUserService.query(m));
			print(sysUserService.setOrderBy("userName", "DESC").query(m));
			print(sysUserService.query(m));
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	@Test
	public void testPageable(){
		try {
			Pageable pageable=new PageRequest(1, 10); //页码从1开始，每页10条数据
			SysUser m=new SysUser();
			m.setStatus(false);
            print(sysUserService.query(m, pageable).getContents());
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	@Test
	public void testSave(){
		try {
			SysUser m=new SysUser();
			m.setUserId((long)16);
			m.setStatus(false);
			m.setCreateDate(new Date());
			m.setUserName("我的测试");
			print(sysUserService.save(m));
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
	
	public void print(SysUser sysUser){
		if(sysUser==null){
			System.err.println("sysUser 为  null");
			return;
		}
		System.out.println(sysUser.getUserId()+" "+sysUser.getUserName()+" "+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(sysUser.getCreateDate()));
	}
	
	public void print(List<SysUser> ls){
		for(SysUser sysUser:ls){
			System.out.println(sysUser.getUserId()+" "+sysUser.getUserName()+" "+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(sysUser.getCreateDate()));
		}
		System.out.println();
	}
	

注意：以上 业务层代码也是一样； 
关于命名的规则（建议）： 
     查询一条数据的方法 以find*,get* 开头； 
     查询多条数据的方法 以 query*,list* 开头； 
     添加数据的方法以 insert* 或 save*方法开头； 
     删除数据方法以 delete*,del* 开头；
     更新数据方法以 update* 开头

具体的实现demo请参考 项目代码中 src/test/java/com.simple.orm.test 包下的实现方式；
```