CREATE DATABASE tedu_store;USE tedu_store;

   CREATE TABLE t_user (uid INT AUTO_INCREMENT COMMENT '用户id',username VARCHAR(20) NOT NULL UNIQUE COMMENT '用户名',password CHAR(32) NOT NULL COMMENT '密码',salt CHAR(36) COMMENT '盐值',phone VARCHAR(20) COMMENT '电话号码',email VARCHAR(30) COMMENT '电子邮箱',gender INT COMMENT '性别:0-女，1-男',avatar VARCHAR(50) COMMENT '头像',is_delete INT COMMENT '是否删除：0-未删除，1-已删除',created_user VARCHAR(20) COMMENT '创建人',created_time DATETIME COMMENT '创建时间',modified_user VARCHAR(20) COMMENT '修改人',modified_time DATETIME COMMENT '修改时间',PRIMARY KEY (uid)) DEFAULT CHARSET=utf8mb4;

  @Autowiredprivate DataSource dataSource;@Testpublic void getConnection() throws Exception {Connection conn = dataSource.getConnection();System.err.println(conn);}

  abstract class BaseEntity implements Serializable {private String createdUser;private Date createdTime;private String modifiedUser;private Date modifiedTime;// GET/SET/toString()}

   public class User extends BaseEntity {private Integer uid;private String username;private String password;private String salt;private String phone;private String email;private Integer gender;private String avatar;private Integer isDelete;// GET/SET/hashCode()/equals()/toString()}

 select * from t_user where username=?

    /*** 处理用户数据操作的持久层接口*/public interface UserMapper {/*** 插入用户数据* @param user 用户数据* @return 受影响的行数*/Integer insert(User user);/*** 根据用户名查询用户数据* @param username 用户名* @return 匹配的用户数据，如果没有匹配的数据，则返回null*/User findByUsername(String username);}

   <mapper namespace="cn.tedu.store.mapper.UserMapper"><resultMap id="UserEntityMap"type="cn.tedu.store.entity.User"><id column="uid" property="uid"/><result column="is_delete" property="isDelete"/><result column="created_user" property="createdUser"/><result column="created_time" property="createdTime"/><result column="modified_user" property="modifiedUser"/><result column="modified_time" property="modifiedTime"/></resultMap><!-- 插入用户数据 --><!-- Integer insert(User user) --><insert id="insert"useGeneratedKeys="true"keyProperty="uid">INSERT INTO t_user (username, password,salt, phone,email, gender,avatar, is_delete,created_user, created_time,modified_user, modified_time) VALUES (#{username}, #{password},#{salt}, #{phone},#{email}, #{gender},#{avatar}, #{isDelete},#{createdUser}, #{createdTime},#{modifiedUser}, #{modifiedTime})</insert><!-- 根据用户名查询用户数据 --><!-- User findByUsername(String username) --><select id="findByUsername"resultMap="UserEntityMap">SELECT*FROMt_userWHEREusername=#{username}</select></mapper>

  @RunWith(SpringRunner.class)@SpringBootTestpublic class UserMapperTests {@Autowiredprivate UserMapper mapper;@Testpublic void insert() {User user = new User();user.setUsername("mybatis");user.setPassword("1234");Integer rows = mapper.insert(user);System.err.println("rows=" + rows);}@Testpublic void findByUsername() {String username = "mybatis";User result = mapper.findByUsername(username);System.err.println(result);}}

    void reg(User user);

  @Servicepublic class UserServiceImpl implements IUserService {@Autowiredprivate UserMapper userMapper;}

    /*** 执行密码加密* @param password 原密码* @param salt 盐值* @return 加密后的密文*/private String getMd5Password(String password, String salt) {// 【加密规则】// 1. 无视原始密码的强度；// 2. 使用UUID作为盐值，在原始密码的左右两侧拼接；// 3. 循环加密3次。for (int i = 0; i < 3; i++) {password = DigestUtils.md5DigestAsHex((salt + password + salt).getBytes()).toUpperCase();}return password;}@Overridepublic void reg(User user) {// 根据参数user获取尝试注册的用户名String username = user.getUsername();// 调用持久层的User findByUsername(String username)方法，根据用户名查询用户数据User result = userMapper.findByUsername(username);// 判断查询结果是否不为nullif (result != null) {// 是：表示用户名已经被占用，抛出UsernameDuplicateExceptionthrow new UsernameDuplicateException();}// 创建当前时间对象Date now = new Date();// 补全数据：加密后的密码String salt = UUID.randomUUID().toString().toUpperCase();String md5Password = getMd5Password(user.getPassword(), salt);user.setPassword(md5Password);// 补全数据：盐值user.setSalt(salt);// 补全数据：isDelete(0)user.setIsDelete(0);// 补全数据：4项日志属性user.setCreatedUser(username);user.setCreatedTime(now);user.setModifiedUser(username);user.setModifiedTime(now);// 表示用户名没有占用，允许注册// 调用持久层的Integer insert(User user)方法执行注册，并获取返回值(受影响的行数)Integer rows = userMapper.insert(user);// 判断受影响的行数是否不为1if (rows != 1) {// 是：插入数据时出现某种错误，抛出InsertExceptionthrow new InsertException();}}

 @RunWith(SpringRunner.class)@SpringBootTestpublic class UserServiceTests {@Autowiredprivate IUserService service;@Testpublic void reg() {try {User user = new User();user.setUsername("service");user.setPassword("1234");service.reg(user);System.err.println("注册成功！");} catch (ServiceException e) {System.err.println("注册失败！" + e.getClass().getSimpleName());}}}

   public class JsonResult<E> {private Integer state; // 状态private String message; // 错误描述private E data; // 数据}

   @RequestMapping("users")@RestControllerpublic class UserController {@Autowiredprivate IUserService userService;}

 @RequestMapping("reg")public JsonResult<Void> reg(User user) {// 创建返回值JsonResult<Void> jr = new JsonResult<>();try {// 调用业务对象执行注册userService.reg(user);// 响应成功jr.setState(1);} catch (UsernameDuplicateException e) {// 用户名冲突：被占用jr.setState(2);jr.setMessage("用户名已经被占用");} catch (InsertException e) {// 插入数据异常jr.setState(3);jr.setMessage("注册失败，请联系系统管理员");}return jr;}

  public JsonResult() {super();}public JsonResult(Integer state) {super();this.state = state;}public JsonResult(Throwable e) {super();this.message = e.getMessage();}

  /*** 控制器类的基类*/public class BaseController {/*** 操作成功的状态码*/public static final int OK = 2000;@ExceptionHandler(ServiceException.class)public JsonResult<Void> handleException(Throwable e) {JsonResult<Void> jr = new JsonResult<>(e);if (e instanceof UsernameDuplicateException) {jr.setState(4000);} else if (e instanceof InsertException) {jr.setState(5000);}return jr;}}

   /*** 处理用户相关请求的控制器类*/@RequestMapping("users")@RestControllerpublic class UserController extends BaseController {@Autowiredprivate IUserService userService;@RequestMapping("reg")public JsonResult<Void> reg(User user) {// 调用业务对象执行注册userService.reg(user);// 返回return new JsonResult<>(OK);}}

   $("#btn-reg").click(function() {$.ajax({"url":"/users/reg","data":$("#form-reg").serialize(),"type":"POST","dataType":"json","success":function(json) {if (json.state == 2000) {alert("注册成功！");} else {alert("注册失败！" + json.message + "！");}}});});

    select * from t_user where username=?

    User login(String username, String password);

 @Overridepublic User login(String username, String password) {// 调用userMapper的findByUsername()，根据参数username查询用户数据User result = userMapper.findByUsername(username);// 判断查询结果是否为nullif (result == null) {// 是：抛出UserNotFoundExceptionthrow new UserNotFoundException("用户名错误");}// 判断查询结果中的isDelete是否为1if (result.getIsDelete() == 1) {// 是：抛出UserNotFoundExceptionthrow new UserNotFoundException("用户名错误");}// 从查询结果中获取盐值String salt = result.getSalt();// 调用getMd5Password()将参数password和salt结合起来加密String md5Password = getMd5Password(password, salt);// 判断查询结果中的密码，与以上加密得到的密码，是否不一致if (!result.getPassword().equals(md5Password)) {// 是：抛出PasswordNotMatchExceptionthrow new PasswordNotMatchException("密码错误");}// 创建新的User对象User user = new User();// 将查询结果中的uid、username、avatar封装到新User对象中user.setUid(result.getUid());user.setUsername(result.getUsername());user.setAvatar(result.getAvatar());// 返回新User对象return user;}

    @Testpublic void login() {try {String username = "spring";String password = "1234";User user = service.login(username, password);System.err.println("登录成功！" + user);} catch (ServiceException e) {System.err.println("登录失败！" + e.getClass().getSimpleName());System.err.println(e.getMessage());}}

 @RequestMapping("login")public JsonResult<User> login(String username, String password) {// 调用业务对象的方法执行登录，并获取返回值// 将以上返回值和状态码OK封装到响应结果中，并返回}

    public JsonResult(Integer state, E data) {super();this.state = state;this.data = data;}

    @RequestMapping("login")public JsonResult<User> login(String username, String password) {// 调用业务对象的方法执行登录，并获取返回值User data = userService.login(username, password);// 将以上返回值和状态码OK封装到响应结果中，并返回return new JsonResult<>(OK, data);}

    update t_user set password=?, modified_user=?, modified_time=? where uid=?

    select * from t_user where uid=?

 Integer updatePasswordByUid(@Param("uid") Integer uid, @Param("password") String password, @Param("modifiedUser") String modifiedUser, @Param("modifiedTime") Date modifiedTime);User findByUid(Integer uid);

 <!-- 根据uid更新用户的密码 --><!-- Integer updatePasswordByUid(@Param("uid") Integer uid, @Param("password") String password, @Param("modifiedUser") String modifiedUser, @Param("modifiedTime") Date modifiedTime) --><update id="updatePasswordByUid">UPDATEt_userSETpassword=#{password},modified_user=#{modifiedUser},modified_time=#{modifiedTime}WHEREuid=#{uid}</update><!-- 根据用户id查询用户数据 --><!-- User findByUid(Integer uid) --><select id="findByUid"resultMap="UserEntityMap">SELECT*FROMt_userWHEREuid=#{uid}</select>

  @Testpublic void updatePasswordByUid() {Integer uid = 17;String password = "1234";String modifiedUser = "超级管理员";Date modifiedTime = new Date();Integer rows = mapper.updatePasswordByUid(uid, password, modifiedUser, modifiedTime);System.err.println("rows=" + rows);}@Testpublic void findByUid() {Integer uid = 17;User result = mapper.findByUid(uid);System.err.println(result);}

    void changePassword(Integer uid, String username, String oldPassword, String newPassword);

    @Overridepublic void changePassword(Integer uid, String username, String oldPassword, String newPassword) {// 调用userMapper的findByUid()方法，根据参数uid查询用户数据User result = userMapper.findByUid(uid);// 检查查询结果是否为nullif (result == null) {// 是：抛出UserNotFoundExceptionthrow new UserNotFoundException("用户数据不存在");}// 检查查询结果中的isDelete是否为1if (result.getIsDelete().equals(1)) {// 是：抛出UserNotFoundExceptionthrow new UserNotFoundException("用户数据不存在");}// 从查询结果中取出盐值String salt = result.getSalt();// 将参数oldPassword结合盐值加密，得到oldMd5PasswordString oldMd5Password = getMd5Password(oldPassword, salt);// 判断查询结果中的password与oldMd5Password是否不一致if (!result.getPassword().contentEquals(oldMd5Password)) {// 是：抛出PasswordNotMatchExceptionthrow new PasswordNotMatchException("原密码错误");}// 将参数newPassword结合盐值加密，得到newMd5PasswordString newMd5Password = getMd5Password(newPassword, salt);// 创建当前时间对象Date now = new Date();// 调用userMapper的updatePasswordByUid()更新密码，并获取返回值Integer rows = userMapper.updatePasswordByUid(uid, newMd5Password, username, now);// 判断以上返回的受影响行数是否不为1if (rows != 1) {// 是：抛了UpdateExceptionthrow new UpdateException("更新用户数据时出现未知错误，请联系系统管理员");}}

 @Testpublic void changePassword() {try {Integer uid = 18;String username = "密码管理员";String oldPassword = "1234";String newPassword = "8888";service.changePassword(uid, username, oldPassword, newPassword);System.err.println("OK");} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}

  @RequestMapping("change_password")public JsonResult<Void> changePassword(String oldPassword, String newPassword, HttpSession session) {// 调用session.getAttribute()获取uid和username// 调用业务对象执行修改密码// 返回成功}

   /*** 从Session中获取uid* @param session HttpSession对象* @return 当前登录的用户的id*/protected final Integer getUidFromSession(HttpSession session) {return Integer.valueOf(session.getAttribute("uid").toString());}/*** 从Session中获取用户名* @param session HttpSession对象* @return 当前登录的用户名*/protected final String getUsernameFromSession(HttpSession session) {return session.getAttribute("username").toString();}

  @RequestMapping("change_password")public JsonResult<Void> changePassword(String oldPassword, String newPassword, HttpSession session) {// 调用session.getAttribute()获取uid和usernameInteger uid = getUidFromSession(session);String username = getUsernameFromSession(session); // 调用业务对象执行修改密码userService.changePassword(uid, username, oldPassword, newPassword);// 返回成功return new JsonResult<>(OK);}

  public class LoginInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {if (request.getSession().getAttribute("uid") == null) {response.sendRedirect("/web/login.html");return false;}return true;}}

   @Configurationpublic class LoginInterceptorConfigurer implements WebMvcConfigurer {@Overridepublic void addInterceptors(InterceptorRegistry registry) {// 创建拦截器对象HandlerInterceptor interceptor= new LoginInterceptor();// 白名单List<String> patterns = new ArrayList<>();patterns.add("/bootstrap3/**");patterns.add("/js/**");patterns.add("/css/**");patterns.add("/images/**");patterns.add("/web/register.html");patterns.add("/web/login.html");patterns.add("/users/reg");patterns.add("/users/login");// 通过注册工具添加拦截器registry.addInterceptor(interceptor).addPathPatterns("/**").excludePathPatterns(patterns);}}

   "error":function(xhr) {alert("您的登录信息已经过期，请重新登录！\n\nHTTP响应码：" + xhr.status);// location.href = "login.html";}

    update t_user set phone=?,email=?,gender=?,modified_user=?,modified_time=? where uid=?

    select * from t_user where uid=?

    Integer updateInfoByUid(User user);

 <!-- 根据uid更新用户资料 --><!-- Integer updateInfoByUid(User user) --><update id="updateInfoByUid">UPDATEt_userSET<if test="phone != null">phone=#{phone},</if><if test="email != null">email=#{email},</if><if test="gender != null">gender=#{gender},</if>modified_user=#{modifiedUser},modified_time=#{modifiedTime}WHEREuid=#{uid}</update>

    @Testpublic void updateInfoByUid() {User user = new User();user.setUid(19);user.setPhone("13800138019");user.setEmail("root@tedu.cn");user.setGender(1);user.setModifiedUser("系统管理员");user.setModifiedTime(new Date());Integer rows = mapper.updateInfoByUid(user);System.err.println("rows=" + rows);}

    User getByUid(Integer uid);void changeInfo(Integer uid, String username, User user);

   @Overridepublic User getByUid(Integer uid) {// 调用userMapper的findByUid()方法，根据参数uid查询用户数据User result = userMapper.findByUid(uid);// 检查查询结果是否为nullif (result == null) {// 是：抛出UserNotFoundExceptionthrow new UserNotFoundException("用户数据不存在");}// 检查查询结果中的isDelete是否为1if (result.getIsDelete().equals(1)) {// 是：抛出UserNotFoundExceptionthrow new UserNotFoundException("用户数据不存在");}// 创建新的User对象User user = new User();// 将以上查询结果中的username/phone/email/gender封装到新User对象中user.setUsername(result.getUsername());user.setPhone(result.getPhone());user.setEmail(result.getEmail());user.setGender(result.getGender());// 返回新User对象return user;}@Overridepublic void changeInfo(Integer uid, String username, User user) {// 调用userMapper的findByUid()方法，根据参数uid查询用户数据User result = userMapper.findByUid(uid);// 检查查询结果是否为nullif (result == null) {// 是：抛出UserNotFoundExceptionthrow new UserNotFoundException("用户数据不存在");}// 检查查询结果中的isDelete是否为1if (result.getIsDelete().equals(1)) {// 是：抛出UserNotFoundExceptionthrow new UserNotFoundException("用户数据不存在");}// 向参数user中补全数据:uiduser.setUid(uid);// 向参数user中补全数据:modifiedUser(username)user.setModifiedUser(username);// 向参数user中补全数据:modifiedTime(new Date())user.setModifiedTime(new Date());// 调用userMapper的updateInfoByUid(User user)方法执行修改，并获取返回值Integer rows = userMapper.updateInfoByUid(user);// 判断以上返回的受影响行数是否不为1if (rows != 1) {// 是：抛了UpdateExceptionthrow new UpdateException("更新用户数据时出现未知错误，请联系系统管理员");}}

  @Testpublic void getByUid() {try {Integer uid = 20;User user = service.getByUid(uid);System.err.println(user);} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}@Testpublic void changeInfo() {try {Integer uid = 20;String username = "数据管理员";User user = new User();user.setGender(1);user.setPhone("13900139020");user.setEmail("user20@tedu.cn");service.changeInfo(uid, username, user);System.err.println("OK.");} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}

 @GetMapping("get_by_uid")public JsonResult<User> getByUid(HttpSession session) {// 从Session中获取uidInteger uid = getUidFromSession(session);// 调用业务对象执行获取数据User data = userService.getByUid(uid);// 响应成功和数据return new JsonResult<>(OK, data);}

   @RequestMapping("change_info")public JsonResult<Void> changeInfo(User user, HttpSession session) {// 从Session中获取uid和usernameInteger uid = getUidFromSession(session);String username = getUsernameFromSession(session);// 调用业务对象执行修改用户资料userService.changeInfo(uid, username, user);// 响应成功return new JsonResult<>(OK);}

    <form method="post" enctype="multipart/form-data"><input type="file" /><input type="submit" value="上传" /></form>

    <context:component-scan base-package="cn.tedu.spring" />

    package cn.tedu.spring;import org.springframework.stereotype.Controller;@Controllerpublic class UploadController {}

 @RequestMapping("upload.do")@ResponseBodypublic String upload() {System.out.println("UserController.upload()");return "OK.";}

    <!-- CommonsMultipartResolver --><bean id="multipartResolver"class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>

    <input type="file" name="file" />

   @RequestMapping("upload.do")@ResponseBodypublic String upload(@RequestParam("file") MultipartFile file) {System.out.println("UserController.upload()");return "OK.";}

    @RequestMapping("upload.do")@ResponseBodypublic String upload(@RequestParam("file") MultipartFile file) {System.out.println("UserController.upload()");try {File dest = new File("D:/1.jpg");file.transferTo(dest);} catch (IllegalStateException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}return "OK.";}

    update t_user set avatar=?,modified_user=?,modified_time=? where uid=?

    Integer updateAvatarByUid(@Param("uid") Integer uid, @Param("avatar") String avatar, @Param("modifiedUser") String modifiedUser, @Param("modifiedTime") Date modifiedTime);

  <!-- 根据uid更新用户的头像 --><!-- Integer updateAvatarByUid(@Param("uid") Integer uid, @Param("avatar") String avatar, @Param("modifiedUser") String modifiedUser, @Param("modifiedTime") Date modifiedTime) --><update id="updateAvatarByUid">UPDATEt_userSETavatar=#{avatar},modified_user=#{modifiedUser},modified_time=#{modifiedTime}WHEREuid=#{uid}</update>

    @Testpublic void updateAvatarByUid() {Integer uid = 19;String avatar = "1234";String modifiedUser = "超级管理员";Date modifiedTime = new Date();Integer rows = mapper.updateAvatarByUid(uid, avatar, modifiedUser, modifiedTime);System.err.println("rows=" + rows);}

    void changeAvatar(Integer uid, String username, String avatar);

@Overridepublic void changeAvatar(Integer uid, String username, String avatar) {// 调用userMapper的findByUid()方法，根据参数uid查询用户数据User result = userMapper.findByUid(uid);// 检查查询结果是否为nullif (result == null) {// 是：抛出UserNotFoundExceptionthrow new UserNotFoundException("用户数据不存在");}// 检查查询结果中的isDelete是否为1if (result.getIsDelete().equals(1)) {// 是：抛出UserNotFoundExceptionthrow new UserNotFoundException("用户数据不存在");}// 创建当前时间对象Date now = new Date();// 调用userMapper的updateAvatarByUid()方法执行更新，并获取返回值Integer rows = userMapper.updateAvatarByUid(uid, avatar, username, now);// 判断以上返回的受影响行数是否不为1if (rows != 1) {// 是：抛出UpdateExceptionthrow new UpdateException("更新用户数据时出现未知错误，请联系系统管理员");}}

 @Testpublic void changeAvatar() {try {Integer uid = 19;String username = "头像管理员";String avatar = "1234";service.changeAvatar(uid, username, avatar);System.err.println("OK");} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}

    @ExceptionHandler({ServiceException.class, FileUploadException.class})

 @Beanpublic MultipartConfigElement getMultipartConfigElement() {MultipartConfigFactory factory= new MultipartConfigFactory();DataSize dataSize = DataSize.ofMegabytes(2);factory.setMaxFileSize(dataSize);factory.setMaxRequestSize(dataSize);return factory.createMultipartConfig();}

    $("#img-avatar").attr("src", json.data);

    $.cookie("avatar", json.data.avatar, { expires: 7 });console.log("cookie中的avatar=" + $.cookie("avatar"));

    <script src="../bootstrap3/js/jquery.cookie.js" type="text/javascript" charset="utf-8"></script>

    $(document).ready(function() {let avatar = $.cookie("avatar");console.log("取出cookie中的头像=" + avatar);$("#img-avatar").attr("src", avatar);});

    $.cookie("avatar", json.data, {expires:7});

    insert into t_address (除了aid以外的字段列表) values (匹配的值列表);

    select count(*) from t_address where uid=?

    Integer insert(Address address);Integer countByUid(Integer uid);

    <mapper namespace="cn.tedu.store.mapper.AddressMapper"><!-- 插入收货地址数据 --><!-- Integer insert(Address address) --><insert id="insert"useGeneratedKeys="true"keyProperty="aid">INSERT INTO t_address (uid, name,province_name, province_code,city_name, city_code,area_name, area_code,zip, address,phone, tel,tag, is_default,created_user, created_time,modified_user, modified_time) VALUES (#{uid}, #{name},#{provinceName}, #{provinceCode},#{cityName}, #{cityCode},#{areaName}, #{areaCode},#{zip}, #{address},#{phone}, #{tel},#{tag}, #{isDefault},#{createdUser}, #{createdTime},#{modifiedUser}, #{modifiedTime})</insert><!-- 统计某用户的收货地址数据的数量 --><!-- Integer countByUid(Integer uid) --><select id="countByUid"resultType="java.lang.Integer">SELECTCOUNT(*)FROMt_addressWHEREuid=#{uid}</select></mapper>

  @RunWith(SpringRunner.class)@SpringBootTestpublic class AddressMapperTests {@Autowiredprivate AddressMapper mapper;@Testpublic void insert() {Address address = new Address();address.setUid(1);address.setName("小王");Integer rows = mapper.insert(address);System.err.println("rows=" + rows);}@Testpublic void countByUid() {Integer uid = 1;Integer count = mapper.countByUid(uid);System.err.println("count=" + count);}}

    void addnew(Integer uid, String username, Address address);

    @Servicepublic class AddressServiceImpl implements IAddressService {@Autowiredprivate AddressMapper addressMapper;}

 @Value("${project.max-count}")public int maxCount;@Overridepublic void addnew(Integer uid, String username, Address address) {// 根据参数uid调用addressMapper的countByUid()方法，统计当前用户的收货地址数据的数量Integer count = addressMapper.countByUid(uid);// 判断数量是否达到上限值if (count >= maxCount) {// 是：抛出AddressCountLimitExceptionthrow new AddressCountLimitException("收货地址数量已经达到上限(" + maxCount + ")！");}// 补全数据：将参数uid封装到参数address中address.setUid(uid);// 补全数据：根据以上统计的数量，得到正确的isDefault值，并封装Integer isDefault = count == 0 ? 1 : 0;address.setIsDefault(isDefault);// 补全数据：4项日志Date now = new Date();address.setCreatedUser(username);address.setCreatedTime(now);address.setModifiedUser(username);address.setModifiedTime(now);// 调用addressMapper的insert()方法插入收货地址数据，并获取返回的受影响行数Integer rows = addressMapper.insert(address);// 判断受影响行数是否不为1if (rows != 1) {// 是：抛出InsertExceptionthrow new InsertException("插入收货地址数据时出现未知错误，请联系系统管理员！");}}

  @Testpublic void addnew() {try {Integer uid = 2;String username = "管理员";Address address = new Address();address.setName("小赵");service.addnew(uid, username, address);System.err.println("OK.");} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}

  @RequestMapping("addresses")@RestControllerpublic class AddressController extends BaseController {@Autowired private IAddressService addressService;}

 @RequestMapping("addnew")public JsonResult<Void>    addnew(Address address, HttpSession session) {// 从Session中获取uid和usernameInteger uid = getUidFromSession(session);String username = getUsernameFromSession(session);// 调用业务对象的方法执行业务addressService.addnew(uid, username, address);// 响应成功return new JsonResult<>(OK);}

    select * from t_dict_district where parent=? order by code;

    List<District> findByParent(String parent);

   <mapper namespace="cn.tedu.store.mapper.DistrictMapper"><!-- 获取全国所有省/某省所有市/某市所有区 --><!-- List<District> findByParent(String parent) --><select id="findByParent"resultType="cn.tedu.store.entity.District">SELECT*FROMt_dict_districtWHEREparent=#{parent}ORDER BY code ASC</select></mapper>

    @RunWith(SpringRunner.class)@SpringBootTestpublic class DistrictMapperTests {@Autowiredprivate DistrictMapper mapper;@Testpublic void findByParent() {String parent = "510000";List<District> list = mapper.findByParent(parent);System.err.println("count=" + list.size());for (District item : list) {System.err.println(item);}}}

    List<District> getByParent(String parent);

   @Servicepublic class DistrictServiceImpl implements IDistrictService {@Autowiredpirvate DistrictMapper districtMapper;}

   @Overridepublic List<District> getByParent(String parent) {List<District> list = districtMapper.findByParent(parent);for (District district : list) {district.setId(null);district.setParent(null);}return list;}

 @RunWith(SpringRunner.class)@SpringBootTestpublic class DistrictServiceTests {@Autowiredprivate IDistrictService service;@Testpublic void getByParent() {try {String parent = "86";List<District> list = service.getByParent(parent);System.err.println("count=" + list.size());for (District item : list) {System.err.println(item);}} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}}

  @RestController@RequestMapping("districts")public class DistrictController extends BaseController {@Autowired private IDistrictService districtService;}

  @GetMapping({"", "/"})public JsonResult<List<District>> getByParent(String parent) {List<District> data = districtService.getByParent(parent);return new JsonResult<>(OK, data);}

    select name from t_dict_district where code=?

    String findNameByCode(String code);

  <!-- 根据省/市/区的行政代号获取省/市/区的名称 --><!-- String findNameByCode(String code) --><select id="findNameByCode"resultType="java.lang.String">SELECTnameFROMt_dict_districtWHEREcode=#{code}</select>

@Testpublic void findNameByCode() {String code = "540000";String name = mapper.findNameByCode(code);System.err.println(name);}

  /*** 根据省/市/区的行政代号获取省/市/区的名称* @param code 省/市/区的行政代号* @return 匹配的省/市/区的名称，如果没有匹配的数据，则返回null*/String getNameByCode(String code);

    @Overridepublic String getNameByCode(String code) {return districtMapper.findNameByCode(code);}

@Testpublic void getNameByCode() {try {String code = "430000";String result = service.getNameByCode(code);System.err.println(result);} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}

    @Autowiredprivate IDistrictService districtService;

    // 补全数据：省、市、区的名称String provinceName = districtService.getNameByCode(address.getProvinceCode());String cityName = districtService.getNameByCode(address.getCityCode());String areaName = districtService.getNameByCode(address.getAreaCode());address.setProvinceName(provinceName);address.setCityName(cityName);address.setAreaName(areaName);

    select * from t_address where uid=? order by is_default desc, created_time desc

    List<Address> findByUid(Integer uid);

    <resultMap id="AddressEntityMap"type="cn.tedu.store.entity.Address"><id column="aid" property="aid"/><result column="province_code" property="provinceCode"/><result column="province_name" property="provinceName"/><result column="city_code" property="cityCode"/><result column="city_name" property="cityName"/><result column="area_code" property="areaCode"/><result column="area_name" property="areaName"/><result column="is_default" property="isDefault"/><result column="created_user" property="createdUser"/><result column="created_time" property="createdTime"/><result column="modified_user" property="modifiedUser"/><result column="modified_time" property="modifiedTime"/></resultMap><!-- 查询某用户的收货地址数据列表 --><!-- List<Address> findByUid(Integer uid) --><select id="findByUid"resultMap="AddressEntityMap">SELECT*FROMt_addressWHEREuid=#{uid}ORDER BYis_default DESC, created_time DESC</select>

 @Testpublic void findByUid() {Integer uid = 19;List<Address> list = mapper.findByUid(uid);System.err.println("count=" + list.size());for (Address item : list) {System.err.println(item);}}

   /*** 查询某用户的收货地址数据列表* @param uid 用户的id* @return 该用户的收货地址数据列表*/List<Address> getByUid(Integer uid);

   @Overridepublic List<Address> getByUid(Integer uid) {List<Address> list = addressMapper.findByUid(uid);for (Address address : list) {address.setUid(null);address.setProvinceCode(null);address.setCityCode(null);address.setAreaCode(null);address.setCreatedUser(null);address.setCreatedTime(null);address.setModifiedUser(null);address.setModifiedTime(null);}return list;}

    @Testpublic void getByUid() {Integer uid = 19;List<Address> list = service.getByUid(uid);System.err.println("count=" + list.size());for (Address item : list) {System.err.println(item);}}

    @GetMapping({"", "/"})public JsonResult<List<Address>> getByUid(HttpSession session) {Integer uid = getUidFromSession(session);List<Address> data = addressService.getByUid(uid);return new JsonResult<>(OK, data);}

    update t_address set is_default=1,modified_user=?,modified_time=? where aid=?

    update t_address set is_default=0 where uid=?

    select * from t_address where aid=?

  Integer updateNonDefaultByUid(Integer uid);Integer updateDefaultByAid(@Param("aid") Integer aid, @Param("modifiedUser") String modifiedUser, @Param("modifiedTime") Date modifiedTime);Address findByAid(Integer aid);

    <!-- 将某用户的所有收货地址设置为非默认 --><!-- Integer updateNonDefaultByUid(Integer uid) --><update id="updateNonDefaultByUid">UPDATEt_addressSETis_default=0WHEREuid=#{uid}</update><!-- 将指定的收货地址设置为默认 --><!-- Integer updateDefaultByAid(@Param("aid") Integer aid, @Param("modifiedUser") String modifiedUser, @Param("modifiedTime") Date modifiedTime) --><update id="updateDefaultByAid">UPDATEt_addressSETis_default=1,modified_user=#{modifiedUser},modified_time=#{modifiedTime}WHEREaid=#{aid}</update><!-- 根据收货地址数据id，查询收货地址详情 --><!-- Address findByAid(Integer aid) --><select id="findByAid"resultMap="AddressEntityMap">SELECT*FROMt_addressWHEREaid=#{aid}</select>

 @Testpublic void updateNonDefaultByUid() {Integer uid = 19;Integer rows = mapper.updateNonDefaultByUid(uid);System.err.println("rows=" + rows);}@Testpublic void updateDefaultByAid() {Integer aid = 27;String modifiedUser = "User27";Date modifiedTime = new Date();Integer rows = mapper.updateDefaultByAid(aid, modifiedUser, modifiedTime);System.err.println("rows=" + rows);}@Testpublic void findByAid() {Integer aid = 27;Address result = mapper.findByAid(aid);System.err.println(result);}

    void setDefault(Integer aid, Integer uid, String username);

   @Override@Transactionalpublic void setDefault(Integer aid, Integer uid, String username) {// 根据参数aid，调用addressMapper中的findByAid()查询收货地址数据Address result = addressMapper.findByAid(aid);// 判断查询结果是否为nullif (result == null) {// 是：抛出AddressNotFoundExceptionthrow new AddressNotFoundException("尝试访问的收货地址数据不存在");}// 判断查询结果中的uid与参数uid是否不一致(使用equals()判断)if (!result.getUid().equals(uid)) {// 是：抛出AccessDeniedException：非法访问throw new AccessDeniedException("非常访问");}// 调用addressMapepr的updateNonDefaultByUid()将该用户的所有收货地址全部设置为非默认，并获取返回的受影响的行数Integer rows = addressMapper.updateNonDefaultByUid(uid);// 判断受影响的行数是否小于1(不大于0)if (rows < 1) {// 是：抛出UpdateExceptionthrow new UpdateException("设置默认收货地址叶出现未知错误[1]");}// 调用addressMapepr的updateDefaultByAid()将指定aid的收货地址设置为默认，并获取返回的受影响的行数rows = addressMapper.updateDefaultByAid(aid, username, new Date());// 判断受影响的行数是否不为1if (rows != 1) {// 是：抛出UpdateExceptionthrow new UpdateException("设置默认收货地址叶出现未知错误[2]");}}

   @Testpublic void setDefault() {try {Integer aid = 2300;Integer uid = 19;String username = "系统管理员";service.setDefault(aid, uid, username);System.err.println("OK.");} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}

    @RequestMapping("{aid}/set_default")public JsonResult<Void> setDefault(@PathVariable("aid") Integer aid, HttpSession session) {Integer uid = getUidFromSession(session);String username = getUsernameFromSession(session);addressService.setDefault(aid, uid, username);return new JsonResult<>(OK);}

public void test(@PathVariable("id") Integer i) {}

  /*** 商品数据的实体类*/public class Product extends BaseEntity {private static final long serialVersionUID = -199568590252555336L;private Integer id;private Integer categoryId;private String itemType;private String title;private String sellPoint;private Long price;private Integer num;private String image;private Integer status;private Integer priority;}

商品-热销排行

52. 商品-热销排行-持久层

**(a) 规划需要执行的SQL语句**

查询热销商品列表的SQL语句大致是：

    select * from t_product where status=1order by priority desc limit 0,4

**(b) 接口与抽象方法**

创建`cn.tedu.store.mapper.ProductMapper`接口，添加方法：

    List<Product> findHostList();

**(c) 配置SQL映射**

复制得到**ProductMapper.xml**文件，配置以上方法的映射：

 <mapper namespace="cn.tedu.store.mapper.ProductMapper"><resultMap id="ProductEntityMap"type="cn.tedu.store.entity.Product"><id column="id" property="id"/><result column="category_id" property="categoryId"/><result column="item_type" property="itemType"/><result column="sell_point" property="sellPoint"/><result column="created_user" property="createdUser"/><result column="created_time" property="createdTime"/><result column="modified_user" property="modifiedUser"/><result column="modified_time" property="modifiedTime"/></resultMap><!-- 查询热销商品的前4名 --><!-- List<Product> findHostList() --><select id="findHostList"resultMap="ProductEntityMap">SELECT*FROMt_productWHEREstatus=1ORDER BYpriority DESCLIMIT 0,4</select></mapper>

创建`ProductMapperTests`测试类，测试：

  @RunWith(SpringRunner.class)@SpringBootTestpublic class ProductMapperTests {@Autowiredprivate ProductMapper mapper;@Testpublic void findHostList() {List<Product> list = mapper.findHostList();System.err.println("count=" + list.size());for (Product item : list) {System.err.println(item);}}}

53. 商品-热销排行-业务层

**(a) 规划异常**

无

**(b) 接口与抽象方法**

创建`cn.tedu.store.service.IProductService`接口，并添加：

    List<Product> getHotList();

**(c) 实现抽象方法**

创建`cn.tedu.store.service.impl.ProductServiceImpl`类，实现以上接口，添加`@Service`注解，在类中声明持久层对象：

  @Servicepublic class ProductServiceImpl implements IProductService {@Autowiredprivate ProductMapper productMapper;public List<Product> getHotList() {}}

在业务层实现中私有实现持久层的方法：

    private List<Product> findHotList() {return productMapper.findHotList();}

然后，实现抽象方法：

    @Overridepublic List<Product> getHotList() {List<Product> list = findHotList();for (Product product : list) {product.setPriority(null);product.setCreatedUser(null);product.setCreatedTime(null);product.setModifiedUser(null);product.setModifiedTime(null);}return list;}

最后，测试：

  @RunWith(SpringRunner.class)@SpringBootTestpublic class ProductServiceTests {@Autowiredprivate IProductService service;@Testpublic void getHotList() {try {List<Product> list = service.getHotList();System.err.println("count=" + list.size());for (Product item : list) {System.err.println(item);}} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}}

54. 商品-热销排行-控制器

**(a) 处理异常**

无

**(b) 设计请求**
设计用户提交的请求，并设计响应的方式：

请求路径：/products/hot_list
    请求参数：无
    请求类型：GET
    响应结果：JsonResult<List<Product>>
    是否拦截：否，需要将index.html和products/**添加到白名单

**(c) 处理请求**

创建`cn.tedu.store.controller.ProductController`控制器类，继承自`BaseController`，添加`@RestController`和`@RequestMapping("products")`注解，并在类中添加业务层对象：

   @RestController@RequestMapping("products")public class ProductController extends BaseController {@Autowiredprivate IProductService productService;}

在类中添加处理请求的方法：

    @RequestMapping("hot_list")public JsonResult<List<Product>> getHotList() {List<Product> data = productService.getHotList();return new JsonResult<>(OK, data);}

测试：http://localhost:8080/products/hot_list

55. 商品-热销排行-前端页面

商品-显示商品详情

56. 商品-显示商品详情-持久层

**(a) 规划需要执行的SQL语句**

根据商品id显示详情的SQL语句大致是：

    select * from t_product where id=?

**(b) 接口与抽象方法**

在`ProductMapper`中添加抽象方法：

    Product findById(Integer id);

**(c) 配置SQL映射**
映射：

   <!-- 根据商品id查询商品详情 --><!-- Product findById(Integer id) --><select id="findById"resultMap="ProductEntityMap">SELECT*FROMt_productWHEREid=#{id}</select>

测试：

 @Testpublic void findById() {Integer id = 10000017;Product result = mapper.findById(id);System.err.println(result);}

57. 商品-显示商品详情-业务层

**(a) 规划异常**

如果商品数据不存在，应该抛出`ProductNotFoundException`。
所以，需要创建`cn.tedu.store.service.ex.ProductNotFoundException`。

**(b) 接口与抽象方法**
在`IProductService`中添加：

    Product getById(Integer id);

**(c) 实现抽象方法**
在`ProductServiceImpl`中，先私有实现持久层新添加的方法：

/*** 根据商品id查询商品详情* @param id 商品id* @return 匹配的商品详情，如果没有匹配的数据，则返回null*/private Product findById(Integer id) {return productMapper.findById(id);}

然后，重写业务接口中的抽象方法：

    @Overridepublic Product getById(Integer id) {Product product = findById(id);if (product == null) {throw new ProductNotFoundException("尝试访问的商品数据不存在");}product.setPriority(null);product.setCreatedUser(null);product.setCreatedTime(null);product.setModifiedUser(null);product.setModifiedTime(null);return product;}

测试方法：

 @Testpublic void getById() {try {Integer id = 100000179;Product result = service.getById(id);System.err.println(result);} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}

58. 商品-显示商品详情-控制器

**(a) 处理异常**

需要处理`ProductNotFoundException`。

**(b) 设计请求**
设计用户提交的请求，并设计响应的方式：

请求路径：/products/{id}/details
    请求参数：@PathVariable("id") Integer id
    请求类型：GET
    响应结果：JsonResult<Product>

**(c) 处理请求**
处理：

    @GetMapping("{id}/details")public JsonResult<Product> getById(@PathVariable("id") Integer id) {// 调用业务对象执行获取数据Product data = productService.getById(id);// 返回成功和数据return new JsonResult<>(OK, data);}

测试： http://localhost:8080/products/10000017/details    http://localhost:8080/products/1/details

59. 商品-显示商品详情-前端页面

60. 购物车-创建数据表

CREATE TABLE t_cart (cid INT AUTO_INCREMENT COMMENT '购物车数据id',uid INT NOT NULL COMMENT '用户id',pid INT NOT NULL COMMENT '商品id',price BIGINT COMMENT '加入时商品单价',num INT COMMENT '商品数量',created_user VARCHAR(20) COMMENT '创建人',created_time DATETIME COMMENT '创建时间',modified_user VARCHAR(20) COMMENT '修改人',modified_time DATETIME COMMENT '修改时间',PRIMARY KEY (cid)) DEFAULT CHARSET=UTF8;

61. 购物车-创建实体类

购物车-将商品添加到购物车

62. 购物车-将商品添加到购物车-持久层

**(a) 规划需要执行的SQL语句**

向数据表中插入新的购物车数据的SQL语句大致是：

    insert into t_cart (除了cid以外的字段列表) values (匹配的值列表);

并不是所有时候点击“加入购物车”都会插入新的数据，如果该用户曾经将该商品加入到购物车了，后续点击时，只会增加商品的数量：

    update t_cart set num=? where cid=?

关于判断“到底应该插入数据，还是修改数量”，可以通过“查询某用户是否已经添加某商品到购物车”，SQL语句大致是：

    select * from t_cart where uid=? and pid=?

以上查询，如果查询到某结果，就表示该用户已经将该商品加入到购物车了，如果查询结果为null，则表示该用户没有添加过该商品。

**(b) 接口与抽象方法**

创建`cn.tedu.store.mapper.CartMapper`接口，添加抽象方法：

 /*** 处理购物车数据的持久层接口*/public interface CartMapper {/*** 插入购物车数据* @param cart* @return*/Integer insert(Cart cart);/*** 修改购物车数据中商品的数量* @param cid 购物车数据的id* @param num 新的数量* @param modifiedUser 修改执行人* @param modifiedTime 修改时间* @return 受影响的行数*/Integer updateNumByCid(@Param("cid") Integer cid, @Param("num") Integer num,@Param("modifiedUser") String modifiedUser, @Param("modifiedTime") Date modifiedTime);/*** 根据用户id和商品id查询购物车中的数据* @param uid 用户id* @param pid 商品id* @return 匹配的购物车数据，如果该用户的购物车中并没有该商品，则返回null*/Cart findByUidAndPid(@Param("uid") Integer uid, @Param("pid") Integer pid);}

**(c) 配置SQL映射**
映射：

 <mapper namespace="cn.tedu.store.mapper.CartMapper"><resultMap id="CartEntityMap"type="cn.tedu.store.entity.Cart"><id column="cid" property="cid"/><result column="created_user" property="createdUser"/><result column="created_time" property="createdTime"/><result column="modified_user" property="modifiedUser"/><result column="modified_time" property="modifiedTime"/></resultMap><!-- 插入购物车数据 --><!-- Integer insert(Cart cart) --><insert id="insert"useGeneratedKeys="true"keyProperty="cid">INSERT INTO t_cart (uid, pid,price, num,created_user, created_time,modified_user, modified_time) VALUES (#{uid}, #{pid},#{price}, #{num},#{createdUser}, #{createdTime},#{modifiedUser}, #{modifiedTime})</insert><!-- 修改购物车数据中商品的数量 --><!-- Integer updateNumByCid(@Param("cid") Integer cid, @Param("num") Integer num,@Param("modifiedUser") String modifiedUser, @Param("modifiedTime") Date modifiedTime) --><update id="updateNumByCid">UPDATE t_cart SETnum=#{num},modified_user=#{modifiedUser},modified_time=#{modifiedTime}WHEREcid=#{cid}</update><!-- 根据用户id和商品id查询购物车中的数据 --><!-- Cart findByUidAndPid(@Param("uid") Integer uid, @Param("pid") Integer pid) --><select id="findByUidAndPid"resultMap="CartEntityMap">SELECT*FROMt_cartWHEREuid=#{uid} AND pid=#{pid}</select></mapper>

测试：

@RunWith(SpringRunner.class)@SpringBootTestpublic class CartMapperTests {@Autowiredprivate CartMapper mapper;@Testpublic void insert() {Cart cart = new Cart();cart.setUid(1);cart.setPid(2);cart.setNum(3);cart.setPrice(4L);Integer rows = mapper.insert(cart);System.err.println("rows=" + rows);}@Testpublic void updateNumByCid() {Integer cid = 1;Integer num = 10;String modifiedUser = "购物车管理员";Date modifiedTime = new Date();Integer rows = mapper.updateNumByCid(cid, num, modifiedUser, modifiedTime);System.err.println("rows=" + rows);}@Testpublic void findByUidAndPid() {Integer uid = 1;Integer pid = 2;Cart result = mapper.findByUidAndPid(uid, pid);System.err.println(result);}}

63. 购物车-将商品添加到购物车-业务层

**(a) 规划异常**

当插入数据时，可能抛出`InsertException`，当修改数据时，可能抛出`UpdateException`；

如果不限制购物车中的记录的数量，则没有其它异常。

**(b) 接口与抽象方法**
创建`cn.tedu.store.service.ICartService`接口，添加抽象方法：

    void addToCart(Integer pid, Integer amount, Integer uid, String username);

**(c) 实现抽象方法**

创建`cn.tedu.store.service.impl.CartServiceImpl`类，实现以上接口，添加`@Service`注解，添加`@Autowired private CartMapper cartMapper;`持久层对象，添加`@Autowired private IProductService productService;`处理商品数据的业务对象：

   @Servicepublic class CartServiceImpl implements ICartService {@Autowiredprivate CartMapper cartMapper;@Autowiredprivate IProductService productService;}

先将持久层中定义的3个方法复制到业务层实现类中，改为私有方法，并实现：

 /*** 插入购物车数据* @param cart*/private void insert(Cart cart) {Integer rows = cartMapper.insert(cart);if (rows != 1) {throw new InsertException("插入商品数据时出现未知错误，请联系系统管理员");}}/*** 修改购物车数据中商品的数量* @param cid 购物车数据的id* @param num 新的数量* @param modifiedUser 修改执行人* @param modifiedTime 修改时间*/private void updateNumByCid(Integer cid, Integer num,String modifiedUser, Date modifiedTime) {Integer rows = cartMapper.updateNumByCid(cid, num, modifiedUser, modifiedTime);if (rows != 1) {throw new InsertException("修改商品数量时出现未知错误，请联系系统管理员");}}/*** 根据用户id和商品id查询购物车中的数据* @param uid 用户id* @param pid 商品id* @return 匹配的购物车数据，如果该用户的购物车中并没有该商品，则返回null*/private Cart findByUidAndPid(Integer uid, Integer pid) {return cartMapper.findByUidAndPid(uid, pid);}

然后，重写业务接口中定义的抽象方法，实现：

@Overridepublic void addToCart(Integer pid, Integer amount, Integer uid, String username) {// 根据参数pid和uid查询购物车中的数据Cart result = findByUidAndPid(uid, pid);Date now = new Date();// 判断查询结果是否为nullif (result == null) {// 是：表示该用户并未将该商品添加到购物车// 创建Cart对象Cart cart = new Cart();// 封装数据：uid,pid,amountcart.setUid(uid);cart.setPid(pid);cart.setNum(amount);// 调用productService.getById()查询商品数据，得到商品价格Product product = productService.getById(pid);// 封装数据：pricecart.setPrice(product.getPrice());// 封装数据：4个日志cart.setCreatedUser(username);cart.setCreatedTime(now);cart.setModifiedUser(username);cart.setModifiedTime(now);// 调用insert(cart)执行将数据插入到数据表中insert(cart);} else {// 否：表示该用户的购物车中已有该商品// 从查询结果中取出原数量，与参数amount相加，得到新的数量Integer num = result.getNum() + amount;// 执行更新数量updateNumByCid(result.getCid(), num, username, now);}}

测试：

 @RunWith(SpringRunner.class)@SpringBootTestpublic class CartServiceTests {@Autowiredprivate ICartService service;@Testpublic void addToCart() {try {Integer pid = 10000007;Integer amount = 1;Integer uid = 2;String username = "不知道";service.addToCart(pid, amount, uid, username);System.err.println("OK.");} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}}

64. 购物车-将商品添加到购物车-控制器

**(a) 处理异常**

无

**(b) 设计请求**

设计用户提交的请求，并设计响应的方式：

   请求路径：/carts/add_to_cart请求参数：Integer pid, Integer amount, HttpSession session请求类型：POST响应结果：JsonResult<Void>

**(c) 处理请求**

创建`cn.tedu.store.controller.CartController`，继承自`BaseController`，添加`@RequestMapping("carts")`和`@RestController`注解，添加`@Autowired private ICartService cartService;`业务对象：

  @RequestMapping("carts")@RestControllerpublic class CartController extends BaseController {@Autowiredprivate ICartService cartService;}

然后，在类中加处理请求的方法：

 @RequestMapping("add_to_cart")public JsonResult<Void> addToCart(Integer pid, Integer amount, HttpSession session) {// 从Session中获取uid和usernameInteger uid = getUidFromSession(session);String username = getUsernameFromSession(session);// 调用业务对象执行添加到购物车cartService.addToCart(pid, amount, uid, username);// 返回成功return new JsonResult<>(OK);}

测试： http://localhost:8080/carts/add_to_cart?pid=10000005&amount=3

65. 购物车-将商品添加到购物车-前端页面

参考“修改密码”。
使用`$.ajax()`函数发出AJAX请求并处理结果时，其中的`"data"`表示将提交的请求参数，请求参数可以有4种方式来处理：
（1） "data" : $("#表单id").serialize() // 适用于参数较多，且都在同一个表单中

（2） "data" : new FormData($("#表单id")[0]) // 仅适用于上传

（3）"data" : "pid=10000005&amount=3"

（4）  "data" : {
        "pid":10000005,
        "amount":3
    }

购物车-显示列表

66. 购物车-显示列表-持久层

**(a) 规划需要执行的SQL语句**

显示某用户的购物车数据列表的SQL语句大致是：

    select cid,pid,uid,title,image,t_cart.price,t_product.price AS realPrice,t_cart.num from t_cart left join t_product on t_cart.pid=t_product.id where uid=19 order by t_cart.created_time desc;

**(b) 接口与抽象方法**
由于涉及多表关联查询，必然没有哪个实体类可以封装此次的查询结果！需要创建VO类！所以，先创建`cn.tedu.store.vo.CartVO`类：

  public class CartVO implements Serializable {private Integer cid;private Integer uid;private Integer pid;private String title;private String image;private Long price;private Long realPrice;private Integer num;// SET/GET// 基于cid的equals()和hashCode()// toString()}

在`CartMapper`接口中添加抽象方法：

    List<CartVO> findVOByUid(Integer uid);

**(c) 配置SQL映射**
映射：

 <!-- 查询某用户的购物车数据 --><!-- List<CartVO> findVOByUid(Integer uid) --><select id="findVOByUid"resultType="cn.tedu.store.vo.CartVO">SELECTcid, pid,uid, title,image, t_cart.price,t_product.price AS realPrice,t_cart.num FROMt_cartLEFT JOINt_productONt_cart.pid=t_product.idWHEREuid=#{uid}ORDER BYt_cart.created_time DESC</select>

测试：

@Testpublic void findVOByUid() {Integer uid = 19;List<CartVO> list = mapper.findVOByUid(uid);System.err.println("count=" + list.size());for (CartVO item : list) {System.err.println(item);}}

67. 购物车-显示列表-业务层

(a) 规划异常

无

(b) 接口与抽象方法

在`ICartService`中添加抽象方法：

    List<CartVO> getVOByUid(Integer uid);

(c) 实现抽象方法

在`CartServiceImpl`中，先添加持久层的方法，调整为私有方法并实现：

  /*** 查询某用户的购物车数据* @param uid 用户id* @return 该用户的购物车数据的列表*/private List<CartVO> findVOByUid(Integer uid) {return cartMapper.findVOByUid(uid);}

然后，重写业务接口中的抽象方法：

    @Overridepublic List<CartVO> getVOByUid(Integer uid) {return findVOByUid(uid);}

测试：

    @Testpublic void getVOByUid() {Integer uid = 19;List<CartVO> list = service.getVOByUid(uid);System.err.println("count=" + list.size());for (CartVO item : list) {System.err.println(item);}}

68. 购物车-显示列表-控制器

(a) 处理异常

无

(b) 设计请求

设计用户提交的请求，并设计响应的方式：

请求路径：/carts/
    请求参数：HttpSession session
    请求类型：GET
    响应结果：JsonResult<List<CartVO>>

(c) 处理请求

代码：

    @GetMapping({"", "/"})public JsonResult<List<CartVO>> getVOByUid(HttpSession session) {// 从Session中获取uidInteger uid = getUidFromSession(session);// 调用业务对象执行查询数据List<CartVO> data = cartService.getVOByUid(uid);// 返回成功与数据return new JsonResult<>(OK, data);}

测试：http://localhost:8080/carts

69. 购物车-显示列表-前端页面

购物车-增加商品数量

70. 购物车-增加商品数量-持久层

(a) 规划需要执行的SQL语句

先查询需要操作的购物车数据：

    select * from t_cart where cid=?

然后，计算出新的数据值，如果允许更新，则更新：

    update t_cart set num=? where cid=?

(b) 接口与抽象方法

在`CartMapper`中添加：

    Cart findByCid(Integer cid);

(c) 配置SQL映射

映射：

  <!-- 根据购物车数据id查询购物车数据详情 --><!-- Cart findByCid(Integer cid) --><select id="findByCid"resultMap="CartEntityMap">SELECT*FROMt_cartWHEREcid=#{cid}</select>

测试：

 @Testpublic void findByCid() {Integer cid = 10;Cart result = mapper.findByCid(cid);System.err.println(result);}

71. 购物车-增加商品数量-业务层

(a) 规划异常

如果尝试访问的购物车数据不存在，则抛出`CartNotFoundException`；

如果尝试访问的数据并不是当前登录用户的数据，则抛出`AccessDeniedException`；

最终将执行更新操作，则可能抛出`UpdateException`；

则需要创建`cn.tedu.store.service.ex.CartNotFoundException`。

(b) 接口与抽象方法

在`ICartService`中添加抽象方法：

    Integer addNum(Integer cid, Integer uid, String username);

(c) 实现抽象方法

在`CartServiceImpl`中，先添加持久层的方法，私有实现：

 /*** 根据购物车数据id查询购物车数据详情* @param cid 购物车数据id* @return 匹配的购物车数据详情，如果没有匹配的数据，则返回null*/private Cart findByCid(Integer cid) {return cartMapper.findByCid(cid);}

实现抽象方法，实现代码：

    @Overridepublic Integer addNum(Integer cid, Integer uid, String username) {// 调用findByCid(cid)根据参数cid查询购物车数据Cart result = findByCid(cid);// 判断查询结果是否为nullif (result == null) {// 是：抛出CartNotFoundExceptionthrow new CartNotFoundException("尝试访问的购物车数据不存在");}// 判断查询结果中的uid与参数uid是否不一致if (!result.getUid().equals(uid)) {// 是：抛出AccessDeniedExceptionthrow new AccessDeniedException("非法访问");}// 可选：检查商品的数量是否大于多少(适用于增加数量)或小于多少(适用于减少数量)// 根据查询结果中的原数量增加1得到新的数量numInteger num = result.getNum() + 1;// 创建当前时间对象，作为modifiedTimeDate now = new Date();// 调用updateNumByCid(cid, num, modifiedUser, modifiedTime)执行修改数量updateNumByCid(cid, num, username, now);// 返回新的数量return num;}

测试：

    @Testpublic void addNum() {try {Integer cid = 12;Integer uid = 19;String username = "不知道";Integer num = service.addNum(cid, uid, username);System.err.println("OK. New num=" + num);} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}

72. 购物车-增加商品数量-控制器

(a) 处理异常

需要处理`CartNotFoundException`。

(b) 设计请求

设计用户提交的请求，并设计响应的方式：

请求路径：/carts/{cid}/num/add
    请求参数：@PathVariable("cid") Integer cid, HttpSession session
    请求类型：POST
    响应结果：JsonResult<Integer>

(c) 处理请求

代码：

    @RequestMapping("{cid}/num/add")public JsonResult<Integer> addNum(@PathVariable("cid") Integer cid, HttpSession session) {// 从Session中获取uid和usernameInteger uid = getUidFromSession(session);String username = getUsernameFromSession(session);// 调用业务对象执行增加数量Integer data = cartService.addNum(cid, uid, username);// 返回成功return new JsonResult<>(OK, data);}

测试：http://localhost:8080/carts/10/num/add

73. 购物车-增加商品数量-前端页面

显示确认订单页-显示勾选的购物车数据

74. 显示确认订单页-显示勾选的购物车数据-持久层

(a) 规划需要执行的SQL语句

在“确认订单页”显示的商品信息，应该来自前序页面(购物车列表)中勾选的数据，所以，显示的信息其实是购物车中的数据！到底显示哪些，取决于用户的勾选操作，当用户勾选了若干条购物车数据后，这些数据的id应该传递到当前“确认订单页”中，该页面根据这些id获取需要显示的数据列表！
所以，在持久层需要完成“根据若干个不确定的id值，查询购物车数据表，显示购物车中的数据信息”！
则需要执行的SQL语句大致是：

    select cid,pid,uid,title,image,t_cart.price,t_product.price AS realPrice,t_cart.num from t_cart left join t_product on t_cart.pid=t_product.id where cid in (?,?,?)order by t_cart.created_time desc;

(b) 接口与抽象方法

在`CartMapper`接口中添加：

    List<CartVO> findVOByCids(Integer[] cids);

(c) 配置SQL映射

映射：

    <!-- 根据若干个购物车数据id查询详情的列表 --><!-- List<CartVO> findVOByCids(Integer[] cids) --><select id="findVOByCids"resultType="cn.tedu.store.vo.CartVO">SELECTcid, pid,uid, title,image, t_cart.price,t_product.price AS realPrice,t_cart.num FROMt_cartLEFT JOINt_productONt_cart.pid=t_product.idWHEREcid IN (<foreach collection="array"item="cid" separator=",">#{cid}</foreach>)ORDER BYt_cart.created_time DESC</select>

测试：

    @Testpublic void findVOByCids() {Integer[] cids = {8,10,12,15,20,30};List<CartVO> list = mapper.findVOByCids(cids);System.err.println("count=" + list.size());for (CartVO item : list) {System.err.println(item);}}

75. 显示确认订单页-显示勾选的购物车数据-业务层-参考购物列表

(a) 规划异常
无

(b) 接口与抽象方法

在`ICartService`中添加抽象方法：

    List<CartVO> getVOByCids(Integer[] cids);

(c) 实现抽象方法

在`CartServiceImpl`中添加私有实现的持久层方法：

    /*** 根据若干个购物车数据id查询详情的列表* @param cids 若干个购物车数据id* @return 匹配的购物车数据详情的列表*/private List<CartVO> findVOByCids(Integer[] cids) {return cartMapper.findVOByCids(cids);}

然后，重写业务接口中的抽象方法：

    @Overridepublic List<CartVO> getVOByCids(Integer[] cids, Integer uid) {List<CartVO> list = findVOByCids(cids);// for (CartVO cart : list) {//     if (!cart.getUid().equals(uid)) {//     list.remove(cart);//     }// }Iterator<CartVO> it = list.iterator();while (it.hasNext()) {CartVO cart = it.next();if (!cart.getUid().equals(uid)) {it.remove();}}return list;}

测试：

    @Testpublic void getVOByCids() {Integer[] cids = {7,13,14,15,16,17};Integer uid = 19;List<CartVO> list = service.getVOByCids(cids, uid);System.err.println("count=" + list.size());for (CartVO item : list) {System.err.println(item);}}

76. 显示确认订单页-显示勾选的购物车数据-控制器-参考购物列表

(a) 处理异常
无

(b) 设计请求

设计用户提交的请求，并设计响应的方式：

请求路径：/carts/list
    请求参数：Integer[] cids, HttpSession session
    请求类型：GET
    响应结果：JsonResult<List<CartVO>>

(c) 处理请求

代码：

    @GetMapping("list")public JsonResult<List<CartVO>> getVOByCids(Integer[] cids, HttpSession session) {// 从Session中获取uidInteger uid = getUidFromSession(session);// 调用业务对象执行查询数据List<CartVO> data = cartService.getVOByCids(cids, uid);// 返回成功与数据return new JsonResult<>(OK, data);}

测试： http://localhost:8080/carts/list?cids=7&cids=8&cids=13&cids=14&cids=17&cids=18

77. 显示确认订单页-显示勾选的购物车数据-前端页面-参考购物列表

创建订单

78. 创建订单-创建数据表

   CREATE TABLE t_order (oid INT AUTO_INCREMENT COMMENT '订单id',uid INT NOT NULL COMMENT '用户id',recv_name VARCHAR(20) NOT NULL COMMENT '收货人姓名',recv_phone VARCHAR(20) COMMENT '收货人电话',recv_province VARCHAR(15) COMMENT '收货人所在省',recv_city VARCHAR(15) COMMENT '收货人所在市',recv_area VARCHAR(15) COMMENT '收货人所在区',recv_address VARCHAR(50) COMMENT '收货详细地址',total_price BIGINT COMMENT '总价',status INT COMMENT '状态：0-未支付，1-已支付，2-已取消，3-已关闭，4-已完成',order_time DATETIME COMMENT '下单时间',pay_time DATETIME COMMENT '支付时间',created_user VARCHAR(20) COMMENT '创建人',created_time DATETIME COMMENT '创建时间',modified_user VARCHAR(20) COMMENT '修改人',modified_time DATETIME COMMENT '修改时间',PRIMARY KEY (oid)) DEFAULT CHARSET=utf8mb4;CREATE TABLE t_order_item (id INT AUTO_INCREMENT COMMENT '订单中的商品记录的id',oid INT NOT NULL COMMENT '所归属的订单的id',pid INT NOT NULL COMMENT '商品的id',title VARCHAR(100) NOT NULL COMMENT '商品标题',image VARCHAR(500) COMMENT '商品图片',price BIGINT COMMENT '商品价格',num INT COMMENT '购买数量',created_user VARCHAR(20) COMMENT '创建人',created_time DATETIME COMMENT '创建时间',modified_user VARCHAR(20) COMMENT '修改人',modified_time DATETIME COMMENT '修改时间',PRIMARY KEY (id)) DEFAULT CHARSET=utf8mb4;

79. 创建订单-创建实体类

   /*** 订单数据的实体类*/public class Order extends BaseEntity {private static final long serialVersionUID = -3216224344757796927L;private Integer oid;private Integer uid;private String recvName;private String recvPhone;private String recvProvince;private String recvCity;private String recvArea;private String recvAddress;private Long totalPrice;private Integer status;private Date orderTime;private Date payTime;}

    /*** 订单中的商品数据*/public class OrderItem extends BaseEntity {private static final long serialVersionUID = -2108307989215829978L;private Integer id;private Integer oid;private Integer pid;private String title;private String image;private Long price;private Integer num;}

80. 创建订单-持久层

创建`cn.tedu.store.mapper.OrderMapper`接口，并在接口中添加：

    Integer insertOrder(Order order);Integer insertOrderItem(OrderItem orderItem);

映射：

    <mapper namespace="cn.tedu.store.mapper.OrderMapper"><!-- 插入订单数据 --><!-- Integer insertOrder(Order order) --><insert id="insertOrder"useGeneratedKeys="true"keyProperty="oid">INSERT INTO t_order (uid,recv_name, recv_phone,recv_province, recv_city,recv_area, recv_address,total_price, status,order_time, pay_time,created_user, created_time,modified_user, modified_time) VALUES (#{uid},#{recvName}, #{recvPhone},#{recvProvince}, #{recvCity},#{recvArea}, #{recvAddress},#{totalPrice}, #{status},#{orderTime}, #{payTime},#{createdUser}, #{createdTime},#{modifiedUser}, #{modifiedTime})</insert><!-- 插入订单商品数据 --><!-- Integer insertOrderItem(OrderItem orderItem) --><insert id="insertOrderItem"useGeneratedKeys="true"keyProperty="id">INSERT INTO t_order_item (oid, pid,title, image,price, num,created_user, created_time,modified_user, modified_time) VALUES (#{oid}, #{pid},#{title}, #{image},#{price}, #{num},#{createdUser}, #{createdTime},#{modifiedUser}, #{modifiedTime})</insert></mapper>

测试：

    @RunWith(SpringRunner.class)@SpringBootTestpublic class OrderMapperTests {@Autowiredprivate OrderMapper mapper;@Testpublic void insertOrder() {Order order = new Order();order.setUid(1);order.setRecvName("小王");Integer rows = mapper.insertOrder(order);System.err.println("rows=" + rows);}@Testpublic void insertOrderItem() {OrderItem orderItem = new OrderItem();orderItem.setOid(1);orderItem.setPid(2);orderItem.setTitle("高档铅笔");Integer rows = mapper.insertOrderItem(orderItem);System.err.println("rows=" + rows);}}

81. 创建订单-业务层

由于处理过程中还需要涉及收货地址数据的处理，所以，需要先在`IAddressService`中添加：

    Address getByAid(Integer aid, Integer uid);

并在`AddressServiceImpl`中实现：

    @Overridepublic Address getByAid(Integer aid, Integer uid) {Address address = findByAid(aid);if (address == null) {throw new AddressNotFoundException("尝试访问的收货地址数据不存在");}if (!address.getUid().equals(uid)) {throw new AccessDeniedException("非法访问");}address.setProvinceCode(null);address.setCityCode(null);address.setAreaCode(null);address.setCreatedUser(null);address.setCreatedTime(null);address.setModifiedUser(null);address.setModifiedTime(null);return address;}

先创建`cn.tedu.store.service.IOrderService`业务层接口，并添加抽象方法：

    Order create(Integer aid, Integer[] cids, Integer uid, String username);

再创建`cn.tedu.store.service.impl.OrderServiceImpl`业务层实现类，实现以上接口，在类之前添加`@Service`注解，在类中添加`@Autowired private OrderMapper orderMapper;`持久层对象和`@Autowired private IAddressService addressService;`、`@Autowired private ICartService cartService;`处理收货地址和购物车数据的对象：

   @Servicepublic class OrderServiceImpl implements IOrderService {@Autowiredprivate OrderMapper orderMapper;@Autowiredprivate IAddressService addressService;@Autowiredprivate ICartService cartService;}

然后，在类中添加持久层的2个方法，私有实现：

    /*** 插入订单数据* @param order 订单数据*/private void insertOrder(Order order) {Integer rows = orderMapper.insertOrder(order);if (rows != 1) {throw new InsertException("插入订单数据时出现未知错误，请联系系统管理员");}}/*** 插入订单商品数据* @param orderItem 订单商品数据*/private void insertOrderItem(OrderItem orderItem) {Integer rows = orderMapper.insertOrderItem(orderItem);if (rows != 1) {throw new InsertException("插入订单商品数据时出现未知错误，请联系系统管理员");}}

最后，重写业务接口中的抽象方法，实现代码：

    @Override@Transactionalpublic Order create(Integer aid, Integer[] cids, Integer uid, String username) {// 创建当前时间对象Date now = new Date();// 根据cids查询所勾选的购物车列表中的数据List<CartVO> carts = cartService.getVOByCids(cids, uid);// 计算这些商品的总价long totalPrice = 0;for (CartVO cart : carts) {totalPrice += cart.getRealPrice() * cart.getNum();}// 创建订单数据对象Order order = new Order();// 补全数据：uidorder.setUid(uid);// 查询收货地址数据Address address = addressService.getByAid(aid, uid);// 补全数据：收货地址相关的6项order.setRecvName(address.getName());order.setRecvPhone(address.getPhone());order.setRecvProvince(address.getProvinceName());order.setRecvCity(address.getCityName());order.setRecvArea(address.getAreaName());order.setRecvAddress(address.getAddress());// 补全数据：totalPriceorder.setTotalPrice(totalPrice);// 补全数据：statusorder.setStatus(0);// 补全数据：下单时间order.setOrderTime(now);// 补全数据：日志order.setCreatedUser(username);order.setCreatedTime(now);order.setModifiedUser(username);order.setModifiedTime(now);// 插入订单数据insertOrder(order);// 遍历carts，循环插入订单商品数据for (CartVO cart : carts) {// 创建订单商品数据OrderItem item = new OrderItem();// 补全数据：oid(order.getOid())item.setOid(order.getOid());// 补全数据：pid, title, image, price, numitem.setPid(cart.getPid());item.setTitle(cart.getTitle());item.setImage(cart.getImage());item.setPrice(cart.getRealPrice());item.setNum(cart.getNum());// 补全数据：4项日志item.setCreatedUser(username);item.setCreatedTime(now);item.setModifiedUser(username);item.setModifiedTime(now);// 插入订单商品数据insertOrderItem(item);}// 返回return order;}

测试：

    @RunWith(SpringRunner.class)@SpringBootTestpublic class OrderServiceTests {@Autowiredprivate IOrderService service;@Testpublic void create() {try {Integer aid = 33;Integer[] cids = {9,12,13,14,15,16};Integer uid = 19;String username = "订单管理员";service.create(aid, cids, uid, username);System.err.println("OK");} catch (ServiceException e) {System.err.println(e.getClass().getSimpleName());System.err.println(e.getMessage());}}}

82. 创建订单-控制器层

关于创建订单的请求的设计：

请求路径：/orders/create
    请求参数：Integer aid, Integer[] cids, HttpSession session
    请求类型：POST
    响应结果：JsonResult<Order>

然后，先创建`cn.tedu.store.controller.OrderController`控制器类，继承自`BaseController`，添加`@RestController`和`@RequestMapping("orders")`注解，在类中添加`@Autowired private IOrderService orderService;`业务对象，然后，添加处理请求的方法：

    @RestController@RequestMapping("orders")public class OrderController extends BaseController {@Autowiredprivate IOrderService orderService;@RequestMapping("create")public JsonResult<Order> create(Integer aid, Integer[] cids,HttpSession session) {// 从Session中取出uid和usernameInteger uid = getUidFromSession(session);String username = getUsernameFromSession(session);// 调用业务对象执行业务Order data = orderService.create(aid, cids, uid, username);// 返回成功与数据return new JsonResult<>(OK, data);}}

测试： http://localhost:8080/order/create?aid=33&cids=8&cids=9&cids=10&cids=11

Spring AOP

AOP：面向切面(Aspect)编程。

AOP并不是Spring框架的特性，只是Spring很好的支持了AOP！

一般数据的处理流程是：

注册：    客户端 -> Controller -> Service.reg() -> Mapper

登录：    客户端 -> Controller -> Service.login() -> Mapper

改密：    客户端 -> Controller -> Service.changePassword() -> Mapper

如果需要在处理每个业务时，都执行特定的代码！则可以假设在整个数据处理流程中存在某个切面，切面中可以定义某些方法，当处理流程执行到切面时，就会自动执行切面中的方法！最终，实现的效果就是：只需要定义好切面方法，配置好切面的位置(连接点)，在不需要修改原有数据处理流程的代码的基础之上，就可以使得若干个流程都执行相同的代码！

在使用Spring AOP编程时，需要先添加2个关于AOP的依赖：

<dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjtools</artifactId>
        <version>1.9.4</version>
    </dependency>

假设需要实现**统计每个业务方法的执行耗时**！

则先创建`cn.tedu.store.aop.TimerAspect`切面类，在类之前添加`@Aspect`和`@Component`注解：

    @Aspect@Componentpublic class TimerAspect {}

然后，在类中添加切面方法，关于切面方法的声明：

1. 应该使用`public`权限；

2. 返回值类型可以是`void`或`Object`，如果使用的注解是`@Around`时，必须使用`Object`作为返回值类型，并返回连接点方法的返回值，如果使用的注解是`@Before`或`@After`时，则自行决定；

3. 方法名称可以自定义；

4. 参数列表中可以添加`ProceedingJoinPoint`接口类型的对象，该对象表示连接点，也可以理解调用切面所在位置对应的方法的对象，如果使用的注解是`@Around`时，必须添加该参数，反之，则不是必须添加；

则添加方法：

    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {// 记录起始时间long start = System.currentTimeMillis();// 执行连接点方法，即切面所在位置对应的方法 // 本例中表示执行注册或执行登录等Object result = pjp.proceed();// 记录结果时间long end = System.currentTimeMillis();// 计算耗时System.err.println("耗时：" + (end - start) + "ms.");// 返回连接点方法的返回值return result;}

然后，需要在方法之前添加注解，以配置连接点，即哪些方法需要应用该切面：

    @Around("execution(* cn.tedu.store.service.impl.*.*(..))")

达内课程结束！！！