详细解答用 idea 自行设计一个数据库项目，分别采用Druid、Mybaties、JDBCTemplate的整合技术，通过定义xml依赖文件和properties属性配置文件，定义实体类，编写持久层、Service层、controller层，完成系统的CRUD功能.

好的，我会详细解答你的问题。在这个项目中，我们将会用到以下技术和工具：

- Java语言
- MySQL数据库
- Spring框架
- Druid连接池
- Mybatis框架
- JDBCTemplate

接下来，我们将会按照以下步骤完成整个项目：

1. 设计数据库模型

我们需要先设计一个简单的数据库，包含两个表：用户表和订单表。用户表包含用户ID、用户名和用户密码，订单表包含订单ID、订单名称和用户ID。我们可以使用以下SQL语句创建这两个表：

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `password` varchar(50) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `order` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) NOT NULL,
  `user_id` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `fk_order_user` (`user_id`),
  CONSTRAINT `fk_order_user` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2. 配置Druid连接池

我们使用Druid作为连接池，可以在pom.xml文件中添加以下依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.6</version>
</dependency>

然后，在Spring配置文件中添加以下内容：

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
</bean>

其中，${jdbc.url}、${jdbc.username}和${jdbc.password}是在properties属性文件中定义的数据库连接参数。

3. 配置Mybatis框架

我们使用Mybatis作为持久层框架，可以在pom.xml文件中添加以下依赖：

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>

然后，在Spring配置文件中添加以下内容：

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="mapperLocations" value="classpath*:com/example/mapper/*.xml" />
</bean>

<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
    <property name="mapperInterface" value="com.example.mapper.UserMapper" />
    <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

<bean id="orderMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
    <property name="mapperInterface" value="com.example.mapper.OrderMapper" />
    <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

其中，com.example.mapper是存放Mybatis的mapper接口和xml文件的包名。

4. 配置JDBCTemplate

我们使用JDBCTemplate作为数据访问层框架，可以在pom.xml文件中添加以下依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.4.RELEASE</version>
</dependency>

然后，在Spring配置文件中添加以下内容：

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>

5. 定义实体类

我们需要定义两个实体类：User和Order。可以在com.example.entity包下创建这两个类，代码如下：

public class User {
    private int id;
    private String username;
    private String password;
    // 省略getter和setter方法
}

public class Order {
    private int id;
    private String name;
    private User user;
    // 省略getter和setter方法
}

注意，订单表中包含用户ID，我们在Order实体类中定义了一个User对象，用来表示订单所属的用户。

6. 编写Mapper接口和xml文件

我们需要编写两个Mapper接口：UserMapper和OrderMapper，并且为每个接口编写一个xml文件，用于定义SQL语句。可以在com.example.mapper包下创建这两个接口和xml文件，代码如下：

public interface UserMapper {
    void addUser(User user);
    void deleteUser(int id);
    void updateUser(User user);
    User getUserById(int id);
    List<User> getAllUsers();
}

public interface OrderMapper {
    void addOrder(Order order);
    void deleteOrder(int id);
    void updateOrder(Order order);
    Order getOrderById(int id);
    List<Order> getAllOrders();
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
    <insert id="addUser" parameterType="com.example.entity.User">
        insert into user (username, password) values (#{username}, #{password})
    </insert>
    <delete id="deleteUser" parameterType="int">
        delete from user where id = #{id}
    </delete>
    <update id="updateUser" parameterType="com.example.entity.User">
        update user set username = #{username}, password = #{password} where id = #{id}
    </update>
    <select id="getUserById" parameterType="int" resultType="com.example.entity.User">
        select * from user where id = #{id}
    </select>
    <select id="getAllUsers" resultType="com.example.entity.User">
        select * from user
    </select>
</mapper>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.OrderMapper">
    <insert id="addOrder" parameterType="com.example.entity.Order">
        insert into order (name, user_id) values (#{name}, #{user.id})
    </insert>
    <delete id="deleteOrder" parameterType="int">
        delete from order where id = #{id}
    </delete>
    <update id="updateOrder" parameterType="com.example.entity.Order">
        update order set name = #{name}, user_id = #{user.id} where id = #{id}
    </update>
    <select id="getOrderById" parameterType="int" resultType="com.example.entity.Order">
        select * from order where id = #{id}
    </select>
    <select id="getAllOrders" resultType="com.example.entity.Order">
        select * from order
    </select>
</mapper>

注意，在OrderMapper的xml文件中，我们使用了#{user.id}来表示订单所属的用户ID。

7. 编写Service层和controller层

我们需要编写两个Service类：UserService和OrderService，并且为每个Service类编写一个controller类，用于处理HTTP请求。可以在com.example.service和com.example.controller包下创建这些类，代码如下：

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public void addUser(User user) {
        userMapper.addUser(user);
    }

    public void deleteUser(int id) {
        userMapper.deleteUser(id);
    }

    public void updateUser(User user) {
        userMapper.updateUser(user);
    }

    public User getUserById(int id) {
        return userMapper.getUserById(id);
    }

    public List<User> getAllUsers() {
        return userMapper.getAllUsers();
    }
}

@Controller
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping("/add")
    public void addUser(@RequestBody User user) {
        userService.addUser(user);
    }

    @DeleteMapping("/delete/{id}")
    public void deleteUser(@PathVariable("id") int id) {
        userService.deleteUser(id);
    }

    @PutMapping("/update")
    public void updateUser(@RequestBody User user) {
        userService.updateUser(user);
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable("id") int id) {
        return userService.getUserById(id);
    }

    @GetMapping("/all")
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }
}

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;

    public void addOrder(Order order) {
        orderMapper.addOrder(order);
    }

    public void deleteOrder(int id) {
        orderMapper.deleteOrder(id);
    }

    public void updateOrder(Order order) {
        orderMapper.updateOrder(order);
    }

    public Order getOrderById(int id) {
        return orderMapper.getOrderById(id);
    }

    public List<Order> getAllOrders() {
        return orderMapper.getAllOrders();
    }
}

@Controller
@RequestMapping("/order")
public class OrderController {
    @Autowired
    private OrderService orderService;

    @PostMapping("/add")
    public void addOrder(@RequestBody Order order) {
        orderService.addOrder(order);
    }

    @DeleteMapping("/delete/{id}")
    public void deleteOrder(@PathVariable("id") int id) {
        orderService.deleteOrder(id);
    }

    @PutMapping("/update")
    public void updateOrder(@RequestBody Order order) {
        orderService.updateOrder(order);
    }

    @GetMapping("/{id}")
    public Order getOrderById(@PathVariable("id") int id) {
        return orderService.getOrderById(id);
    }

    @GetMapping("/all")
    public List<Order> getAllOrders() {
        return orderService.getAllOrders();
    }
}

注意，在controller类中，我们使用了@PostMapping、@DeleteMapping、@PutMapping和@GetMapping来处理HTTP请求，同时使用了@RequestBody和@PathVariable注解来获取请求数据。

8. 编写properties属性文件

我们需要在src/main/resources目录下创建一个名为application.properties的文件，用于定义数据库连接参数。可以添加以下内容：

jdbc.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&useSSL=false
jdbc.username=root
jdbc.password=123456

其中，jdbc.url、jdbc.username和jdbc.password分别表示数据库连接URL、用户名和密码。

9. 测试

我们可以使用Postman等工具来测试系统的CRUD功能。例如，我们可以发送以下HTTP请求来添加一个用户：

POST http://localhost:8080/user/add
Content-Type: application/json

{
    "username": "test",
    "password": "123456"
}

系统将会返回一个HTTP状态码为200的响应，表示添加成功。

接下来，我们可以发送以下HTTP请求来获取所有用户：

GET http://localhost:8080/user/all

系统将会返回一个HTTP状态码为200的响应，其中包含所有用户的信息。

以上就是整个项目的开发流程，包括了使用Druid、Mybatis和JDBCTemplate三种技术的整合。