SSM综合项目实战（TTSC） -- day02 Dubbo注册中心,通用Mapper,分页插件

一、Dubbo的连接方式

1、连接方式介绍

        使用Dubbo进行远程调用实现服务交互，它支持多种协议，如Hessian、HTTP、RMI、Memcached、Redis等等。由于Dubbo将这些协议的实现进行了封装了，无论是服务端（开发服务）还是客户端（调用服务），都不需要关心协议的细节，只需要在配置中指定使用的协议即可，从而保证了服务提供方与服务消费方之间的透明。

        Dubbo的客户端和服务端有三种连接方式，分别是：广播，直连和使用zookeeper注册中心

2、dubbo广播方式

（1）、提供者



（2）、消费者

3、dubbo直连方式

        Dubbo直连，首先要取消广播，然后客户端直接到指定需要的服务的url获取服务即可。这种方式在企业中一般在开发中环境中使用，但是生产环境很少使用，因为服务是直接调用，没有使用注册中心，很难对服务进行管理。

（1）、提供者



（2）、消费者

4、dubbo使用zookeeper注册中心方式

        Dubbo注册中心和广播注册中心配置类似，不过需要指定注册中心类型和注册中心地址，这个时候就不是把服务信息进行广播了，而是告诉给注册中心进行管理，这个时候我们就需要有一个注册中心。

        官方推荐使用zookeeper作为注册中心。

二、使用dubbo注册中心的方式进行连接

1、zookeeper介绍

        注册中心负责服务地址的注册与查找，相当于目录服务，服务提供者在启动时与注册中心交互，消费者不断的发起请求获取服务信息，注册中心不转发请求，压力较小。使用dubbo-2.3.3以上版本，建议使用zookeeper注册中心。

        Zookeeper是Apacahe Hadoop的子项目，是一个树型的目录服务，支持变更推送，适合作为Dubbo服务的注册中心，工业强度较高，可用于生产环境，并推荐使用 

2、搭建linux中的zookeeper环境

（1）、导入Linux虚拟机，帐号密码为：root/root

（2）、导入zookeeper安装包

将zookeeper.tar.gz上传值/usr/local目录中



解压压缩包并进入解压后的文件夹，创建data文件夹



进入conf下，复制配置文件并改名



编辑zoo.cfg，修改数据存放目录



进入bin目录，启动zookeeper

3、zookeeper注册中心在项目中应用

（1）、服务提供者：



（2）、服务消费者：

三、配置zookeeper的监控中心Monitor

1、Linux中上传tomcat并解压

2、将监控中心的war包上传至tomcat的webapps下

3、解压war包，并删除之前的war包

4、启动tomcat，访问监控中心，密码为root/root

四、创建数据库，导入数据资料，创建mybatis测试的maven工程

1、创建数据库

2、导入数据

注意：sql资源在本博客中下载，目前用于测试，因此时候只需要导入user.sql即可

3、创建测试用的mybatis的maven工程

4、编写配置文件

sqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 引入外部资源配置文件 -->
<properties resource="jdbc.properties"></properties>

<settings>
<!-- 开启驼峰自动映射 -->
<setting name="mapUnderscoreToCamelCase" value="true" />
</settings>

<!-- 配置别名 -->
<typeAliases>
<package name="cn.itcast.mybatis.pojo" />
</typeAliases>

<!-- 配置数据库连接信息 -->
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</dataSource>
</environment>
</environments>

<!-- 扫描映射文件包 -->
<mappers>
<package name="cn.itcast.mybatis.mapper" />
</mappers>

</configuration>

User.java

package cn.itcast.mybatis.pojo;

import java.util.Date;

public class User {
// 主键
private Long id;
// 用户名
private String userName;
// 密码
private String password;
// 姓名
private String name;
// 年龄
private Integer age;
// 性别，1男性，2女性
private Integer sex;
// 出生日期
private Date birthday;
// 创建时间
private Date created;
// 更新时间
private Date updated;

public Long getId() {
return id;
}

public void setId(Long id) {
this.id = id;
}

public String getUserName() {
return userName;
}

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

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Integer getAge() {
return age;
}

public void setAge(Integer age) {
this.age = age;
}

public Integer getSex() {
return sex;
}

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

public Date getBirthday() {
return birthday;
}

public void setBirthday(Date birthday) {
this.birthday = birthday;
}

public Date getCreated() {
return created;
}

public void setCreated(Date created) {
this.created = created;
}

public Date getUpdated() {
return updated;
}

public void setUpdated(Date updated) {
this.updated = updated;
}

}

UserMapper.java

package cn.itcast.mybatis.mapper;

import cn.itcast.mybatis.pojo.User;

public interface UserMapper {

/**
* 根据id查询用户
*
* @param id
* @return
*/
User queryUserById(Long id);

/**
* 新增
*
* @param user
*/
void saveUser(User user);

/**
* 更新
*
* @param user
*/
void updateUserById(User user);

/**
* 根据id删除
*
* @param id
*/
void deleteUserById(Long id);

}

UserMapper.xml

<?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="cn.itcast.mybatis.mapper.UserMapper">

<!-- 根据id查询用户 -->
<select id="queryUserById" parameterType="LonG" resultType="user">
SELECT * FROM `user` WHERE id = #{id}
</select>

<!-- 新增用户 -->
<insert id="saveUser" useGeneratedKeys="true" keyColumn="id"
keyProperty="id">
INSERT INTO `user` (
`user_name`,
`password`,
`name`,
`age`,
`sex`,
`birthday`,
`created`,
`updated`
)
VALUES
(
#{userName},
#{password},
#{name},
#{age},
#{sex},
NOW(),
NOW(),
NOW()
)
</insert>

<!-- 修改用户 -->
<update id="updateUserById">
UPDATE `user`
SET
`user_name` = #{userName},
`name` =
#{name}
WHERE
(`id` = #{id});
</update>

<!-- 删除用户 -->
<delete id="deleteUserById">
DELETE FROM `user` WHERE id=#{id}
</delete>

</mapper>

5、编写测试类

package cn.itcast.mybatis.mapper;

import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;

import cn.itcast.mybatis.pojo.User;

public class UserMapperTest {

private UserMapper userMapper;
@Before
public void setUp() throws Exception {
//创建SqlSessionFactoryBuilder
SqlSessionFactoryBuilder builer = new SqlSessionFactoryBuilder();
//读取配置文件
InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
//获取SqlSessionFactroy
SqlSessionFactory sqlSessionFactory = builer.build(inputStream);
//打开session，参数是自动提交事务
SqlSession sqlSession = sqlSessionFactory.openSession(true);
//使用sqlSession获取mapper
this.userMapper = sqlSession.getMapper(UserMapper.class);
}

@Test
public void testQueryUserById() {
User user = this.userMapper.queryUserById(6l);

System.out.println(user);
}

@Test
public void testSaveUser() {

User user = new User();
user.setUserName("delaiwen");
user.setName("荣耀行刑官");

this.userMapper.saveUser(user);

System.out.println(user);
}

@Test
public void testUpdateUserById() {

User user = new User();
user.setId(7l);
user.setUserName("delaiwen123");
user.setName("荣耀行刑官123");

this.userMapper.updateUserById(user);
}

@Test
public void testDeleteUserById() {
this.userMapper.deleteUserById(7l);
}

}

五、通用Mapper的使用

1、通用mapper的集成和使用文档

注意：mapper文档在本博客资源文件中有

2、在测试项目的SqlMapConfig.xml中加入通用mapper的配置

<!-- 通用Mapper的拦截器配置方式 -->
<plugins>
<plugin interceptor="com.github.abel533.mapperhelper.MapperInterceptor">
<!--主键自增回写方法,默认值MYSQL,详细说明请看文档 -->
<property name="IDENTITY" value="MYSQL" />
<!--通用Mapper接口，多个通用接口用逗号隔开 -->
<property name="mappers" value="com.github.abel533.mapper.Mapper" />
</plugin>
</plugins>

3、通用Mapper的使用

（1）、创建通用Mapper的接口

package cn.itcast.mybatis.mapper;

import com.github.abel533.mapper.Mapper;

import cn.itcast.mybatis.pojo.User;

public interface NewUserMapper extends Mapper<User> {

}

（2）、改造POJO类

4、创建测试类

package cn.itcast.mybatis.mapper;

import static org.junit.Assert.*;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;

import com.github.abel533.entity.Example;
import com.github.abel533.entity.Example.Criteria;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;

import cn.itcast.mybatis.pojo.User;

public class NewUserMapperTest {

private NewUserMapper newUserMapper;

@Before
public void setUp() throws Exception {
// 创建SqlSessionFactoryBuilder
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
// 读取配置文件
InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
// 使用Builder获取SqlSessionFactory
SqlSessionFactory sqlSessionFactory = builder.build(inputStream);
// 打开sqlSession
// 参数就是设置是否自动提交事务，如果为true，就是自动提交
SqlSession sqlSession = sqlSessionFactory.openSession(true);
// 使用Sql
102c3
Session获取Mapper
this.newUserMapper = sqlSession.getMapper(NewUserMapper.class);
}

@Test
public void testSelectOne() {
User param = new User();
param.setUserName("liqing");
param.setSex(1);

User user = this.newUserMapper.selectOne(param);

System.out.println(user);

}

@Test
public void testSelect() {
User param = new User();
param.setSex(1);

List<User> list = this.newUserMapper.select(param);

for (User user : list) {
System.out.println(user);
}
}

@Test
public void testSelectCount() {
User param = new User();
// param.setUserName("liqing");
param.setSex(1);

int count = this.newUserMapper.selectCount(param);
System.out.println(count);
}

@Test
public void testSelectByPrimaryKey() {
User user = this.newUserMapper.selectByPrimaryKey(9l);
System.out.println(user);
}

// 新增，不忽略空字段
@Test
public void testInsert() {
User param = new User();
param.setSex(1);
param.setUserName("liubei");
param.setName("刘备");

this.newUserMapper.insert(param);

System.out.println(param);
}

// 新增，忽略空字段
@Test
public void testInsertSelective() {
User param = new User();
param.setSex(1);
param.setUserName("guanyu");
param.setName("关羽");

this.newUserMapper.insertSelective(param);
System.out.println(param);
}

@Test
public void testDelete() {
fail("Not yet implemented");
}

@Test
public void testDeleteByPrimaryKey() {
fail("Not yet implemented");
}

// 更新，不忽略空字段,即：如果其余字段没有设置数据，则置为null（无论之前数据库中有没有数据，都置为null）
@Test
public void testUpdateByPrimaryKey() {
User param = new User();
param.setId(1l);
param.setName("张三123");

this.newUserMapper.updateByPrimaryKey(param);
}

// 更新，忽略空字段
@Test
public void testUpdateByPrimaryKeySelective() {
User param = new User();
param.setId(2l);
param.setName("李四123");

this.newUserMapper.updateByPrimaryKeySelective(param);
}

// -----------------------------------多条件查询-------------------------
@Test
public void testSelectCountByExample() {
// 声明查询对象
Example example = new Example(User.class);

// 使用查询对象创建查询条件对象
Criteria criteria = example.createCriteria();

// 查询条件是，id为3,4,5的用户
// 设置条件，第一个参数就是条件的属性名，第二个参数是查询的条件按数据
List<Object> ids = new ArrayList<>();
ids.add(3);
ids.add(4);
ids.add(5);

criteria.andIn("id", ids);

int count = this.newUserMapper.selectCountByExample(example);
System.out.println(count);

}

@Test
public void testDeleteByExample() {
fail("Not yet implemented");
}

@Test
public void testSelectByExample() {
// 声明查询对象
Example example = new Example(User.class);

// 使用查询对象创建查询条件对象
Criteria criteria = example.createCriteria();

// 查询条件是，id为3,4,5的用户
// 设置条件，第一个参数就是条件的属性名，第二个参数是查询的条件按数据
List<Object> ids = new ArrayList<>();
ids.add(3);
ids.add(4);
ids.add(5);

criteria.andIn("id", ids);

List<User> list = this.newUserMapper.selectByExample(example);

for (User u : list) {
System.out.println(u);
}
}

// 根据条件更新，忽略空字段
@Test
public void testUpdateByExampleSelective() {
// 声明查询对象
Example example = new Example(User.class);

// 使用查询对象创建查询条件对象
Criteria criteria = example.createCriteria();

// 查询条件是，id为3,4,5的用户
// 设置条件，第一个参数就是条件的属性名，第二个参数是查询的条件按数据
List<Object> ids = new ArrayList<>();
ids.add(3);
ids.add(4);
ids.add(5);

// 把条件设置进去
criteria.andIn("id", ids);

// 声明需要把数据修改成什么样
User user = new User();
user.setPassword("123456");

// 第一个参数是，要把数据修改成神马样，第二个参数是要把神马样的数据进行修改，修改的条件
this.newUserMapper.updateByExampleSelective(user, example);
}

// 根据条件更新，不忽略空字段
@Test
public void testUpdateByExample() {
// 声明查询对象
Example example = new Example(User.class);

// 使用查询对象创建查询条件对象
Criteria criteria = example.createCriteria();

// 查询条件是，id为3,4,5的用户
// 设置条件，第一个参数就是条件的属性名，第二个参数是查询的条件按数据
List<Object> ids = new ArrayList<>();
ids.add(3);
ids.add(4);
ids.add(5);

// 把条件设置进去
criteria.andIn("id", ids);

// 声明需要把数据修改成什么样
User user = new User();
user.setPassword("222");

// 第一个参数是，要把数据修改成神马样，第二个参数是要把神马样的数据进行修改，修改的条件
this.newUserMapper.updateByExample(user, example);
}

}

六、分页插件的使用

1、之前分页的实现方法

（1）、在通用mapper接口中添加分页方法

package cn.itcast.mybatis.mapper;

import java.util.List;
import java.util.Map;

import com.github.abel533.mapper.Mapper;

import cn.itcast.mybatis.pojo.User;

public interface NewUserMapper extends Mapper<User> {

/**
* @param map
*            一个key是start，表示从哪一条开始查，另一个key是rows，表示每页显示的数据条数
* @return
*/
public List<User> queryUserByPage(Map<String, Integer> map);

}

（2）、创建NewUserMapper.xml

<?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="cn.itcast.mybatis.mapper.NewUserMapper">

<!-- 根据id查询用户 -->
<select id="queryUserByPage" parameterType="map" resultType="user">
SELECT * FROM `user` LIMIT #{start},#{rows}
</select>

</mapper>

（3）、测试类中的代码

@Test
public void testQueryUserByPage() {
Map<String, Integer> map = new HashMap<>();
map.put("start", 2);
map.put("rows", 3);

List<User> list = this.newUserMapper.queryUserByPage(map);

for (User user : list) {
System.out.println(user);
}
}

2、使用分页插件后分页的实现方法

注意：分页插件的使用文档在本博客资源文件的通用mapper压缩包中

（1）、在sqlMapConfig.xml中配置分页助手的配置

<!-- 配置分页助手 -->
<plugin interceptor="com.github.pagehelper.PageHelper">
<property name="dialect" value="mysql" />
<!-- 该参数默认为false -->
<!-- 设置为true时，使用RowBounds分页会进行count查询 -->
<property name="rowBoundsWithCount" value="true" />
</plugin>

（2）、编写测试类，测试分页方法

/**
* 使用分页助手进行分页测试
*/
@Test
public void testQueryUserByPage2() {
// 设置分页数据
// 第一个参数是从哪一页开始查，第二参数是每页显示的数据条数
PageHelper.startPage(2, 4);

List<User> list = this.newUserMapper.select(null);

for (User user : list) {
System.out.println(user);
}

PageInfo<User> pageInfo = new PageInfo<>(list);

System.out.println("数据总条数："+pageInfo.getTotal());
System.out.println("总页数："+pageInfo.getPages());
}

七、在淘淘商城项目中集成分页插件

1、导入item表数据

2、在SqlMapConfig.xml中加入分页助手和通用Mapper配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

<!-- 注意：分页助手的配置要在通用mapper之前 -->
<plugins>
<!-- 配置分页助手 -->
<plugin interceptor="com.github.pagehelper.PageHelper">
<property name="dialect" value="mysql" />
<!-- 该参数默认为false -->
<!-- 设置为true时，使用RowBounds分页会进行count查询 -->
<property name="rowBoundsWithCount" value="true" />
</plugin>

<!-- 通用Mapper的拦截器配置方式 -->
<plugin interceptor="com.github.abel533.mapperhelper.MapperInterceptor">
<!--主键自增回写方法,默认值MYSQL,详细说明请看文档 -->
<property name="IDENTITY" value="MYSQL" />
<!--通用Mapper接口，多个通用接口用逗号隔开 -->
<property name="mappers" value="com.github.abel533.mapper.Mapper" />
</plugin>
</plugins>

</configuration>

3、导入pojo

注意：所有的pojo在本博客资源文件中都有

4、编写mapper接口和映射文件

（1）、接口

package com.taotao.manager.mapper;

import com.github.abel533.mapper.Mapper;
import com.taotao.manager.pojo.ItemCat;

/**
* 商品类目的通用mapper
* @author Administrator
*
*/
public interface ItemCatMapper extends Mapper<ItemCat> {

}

（2）、映射文件

5、编写Service接口和实现类

（1）、接口

package com.taotao.manager.service;

import java.util.List;

import com.taotao.manager.pojo.ItemCat;

/**
* 商品类目业务层接口
* @author Administrator
*
*/
public interface ItemCatService {

/**
* 分页查询商品类目
* @param page
* @param rows
* @return
*/
public List<ItemCat> queryItemCatByPage(Integer page, Integer rows);
}

（2）、实现类

package com.taotao.manager.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.github.pagehelper.PageHelper;
import com.taotao.manager.mapper.ItemCatMapper;
import com.taotao.manager.pojo.ItemCat;
import com.taotao.manager.service.ItemCatService;

/**
* 商品类目业务层实现类
* @author Administrator
*
*/
@Service
public class ItemCatServiceImpl implements ItemCatService {

@Autowired
private ItemCatMapper itemCatMapper;

/**
* 分页查询商品类目
*/
public List<ItemCat> queryItemCatByPage(Integer page, Integer rows) {
//设置分页参数
PageHelper.startPage(page, rows);

//执行查询
List<ItemCat> list = this.itemCatMapper.select(null);
return list;
}

}

6、编写Web层代码

package com.taotao.manager.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.taotao.manager.pojo.ItemCat;
import com.taotao.manager.service.ItemCatService;

/**
* 商品类目的web层
* @author Administrator
*
*/
@Controller
@RequestMapping("/item/cat")
public class ItemCatController {

@Autowired
private ItemCatService itemCatService;

/**
* 分页查询商品类目
* @PathVariable：将url中的参数映射的方法参数中
* @RequestParam：将url中？号后面的参数映射到方法参数中
* @param page
* @param rows
* @return
*/
@RequestMapping(value="query/{page}")
@ResponseBody
public List<ItemCat> queryItemCatByPage(@PathVariable Integer page, @RequestParam(value="row") Integer rows){
//调用服务进行分页查询
List<ItemCat> list = this.itemCatService.queryItemCatByPage(page, rows);
return list;
}
}

7、在配置文件中声明dubbo的服务注册和调用

8、启动项目，测试运行