发表于： 2021-10-04 21:29:30
1 1057
一，今天完成的事情
任务七
1，这个任务原本的要求是。
1）集成功能到报名系统。
2）能用电子邮箱注册，注册的时候用户填写的电子邮箱能收到验证码。之后能登录。
3）能用手机号注册，注册的时候用户填写的手机能收到验证码。之后能登录。
4）用户能够自主上传图片。一般这个是登录后才能上传。如果自己有一个网站，很可能希望自己能自主上传网页，网页有内容也有图片。这次要上传的图片，可以理解是自己的头像。
5）图片迁移程序。所以要申请至少两个云的账号。
6）我总结的要求2-4是核心要求，任务七的官方说明中还有特别针对这些项目的更具体的要求，比如做好短信通道的防攻击策略，邮箱的防攻击策略。
7）因为要验证登录，还是有拦截器
2，根据demo。我希望展示的也是我总结出来的任务7的情况，所以我建的表就是满足任务7的要求。就是user表。一般其实还会加，用户是否激活的选项。
用户头像也可以单独成表。
注册的模块如果需要captcha辅助，然后才发送验证码，需要也可以单独成表。
3，根据表，建立dao层，mapper。
根据任务七gif，我发现除了id, created at, updated at 3个字段，还有4个字段。最后一个imageurl是要上传图片用的一个字段。这4个字段中password是公用的，但是email, cellphone, username，都是以后可以用来登录的“用户名”。
如果需要注册，那么就是“增加”，这个操作，dao层需要有增加单个用户的操作。根据gif，手机或者邮箱是必须有一个，但是目前可以不处理两个信息都要有。
如果3个以后都可以用，登录的时候选定用户名，要3个都在数据库中查看处理，看看是不是。最后可以收尾到username这个字段上。
<insert id="insertUser" parameterType="com.nicole.registerupload.entity.User">
insert into user (imageurl, username,
email, cellphone, password,
created_at, updated_at)
values (#{imageurl,jdbcType=VARCHAR}, #{username,jdbcType=VARCHAR},
#{email,jdbcType=VARCHAR}, #{cellphone,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR},
#{createdAt,jdbcType=BIGINT}, #{updatedAt,jdbcType=BIGINT})
</insert>
4，建立Service层。如果从controller传进来的数据还需要处理，在这里处理。测试UserService成功，才能排除之后的错误。
package com.nicole.registerupload;
import com.nicole.registerupload.entity.User;
import com.nicole.registerupload.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:spring-mybatis.xml"})
public class UserServiceTest {
@Autowired
private UserService userService;
@Test
@Transactional
@Rollback(true)
public void insertUserTest(){
User user = new User();
user.setImageurl("/image2");
user.setUsername("nicole");
user.setCellphone("+17653379081");
user.setEmail("hidear@gmail.com");
user.setPassword("abcd1234");
user.setCreatedAt( System.currentTimeMillis());
user.setUpdatedAt(System.currentTimeMillis());
userService.insertUser( user) ;
}
}
邮箱或者手机注册，暂时没有电子邮件。插入成功，暂时没有问题。
5，邮箱发送验证码是一种常规的操作。题目要求注册某云的邮箱，但是这个云的使用者不够普遍。根据使用普遍程度，和中国地区的习惯，最推荐寻找qq邮箱，和网易系列邮箱的发送邮件的参考代码。
邮箱需要打开SMTP接口，所以打开POP3/SMTP和IMAP/SMTP接口。不论用哪个，确保打开，而且邮箱会给一个不是密码，是“第三方邮件客户端授权码”的，一般是一个和在网页登录邮箱密码不同的密码，这个可以在自己的服务器端填入，能够发送邮件。有可能有Access Key Secret Key的概念。但是这个任务关键是能发送邮件。
我用的是qq邮箱，所以我先测试有了发送邮箱，key，收件箱，主题，内容甚至地区的情况下，所有要求的域都填写之后，测试是否能正常收发邮件，然后再整合入controller，可能还要修改service。发邮件本身单独的功能代码，不需要用insert任何一层配合。
6，建立Controller层。还有spring-mvc.xml,spring-mybatis.xml。.properties文件除了memcached不要，复制上次的。所有文件都改个包名。
在controller用md5 util把传入的密码加密。
写Controller层的访问地址，要理解jsp页面文件的$path，又是相对路径和绝对路径的问题。
我用了可以配合后端使用的jsp页面emailRegist.jsp，前端有的按钮通过js能够访问后端的接口，看好接口地址，前后端商量好接口地址，在相应的接口地址写相应代码。
这次我的md5是用org.springframework.util包下的DigestUtils加密的。password是变量名，utf-8是希望使用的字符集。
DigestUtils.md5DigestAsHex(password.
getBytes("UTF-8"));
我使用Redis存储验证码，所以取验证码也在Redis中。为了安全，验证码有效期不能太长，我设置就是5分钟有效。每5小时内，只能最多发送5次验证码。这就是我的验证码的攻防策略。注册要处理的问题有：
1）用户名或者邮箱已存在
2）验证码输入错误
3）验证码已经过期
4）邮箱格式不对
邮箱的正则表达式是别人已经写好，我觉得没问题来用的。
//验证邮箱
String mailRegex = "^\\s*\\w+(?:\\.{0,1}[\\w-]+)" +
"*@[a-zA-Z0-9]+(?:[-.][a-zA-Z0-9]+)*\\.[a-zA-Z]+\\s*$";
Pattern p1 = Pattern.compile(mailRegex);
Matcher m1 = p1.matcher(mail);
boolean isMail = m1.matches();
5）5小时内不能发送超过5次，是在Mail Util里写的
生成6位随机数字的算法参考别人。这个方法只有数字。
public String getCode() {
String str="0123456789";
StringBuilder st=new StringBuilder(4);
for(int i=0;i<6;i++){
char ch=str.charAt(new Random().nextInt(str.length()));
st.append(ch);
}
String code=st.toString().toLowerCase();
return code;
}
引用了一个RedisUtil
package com.nicole.registerupload.util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@Component
public class RedisUtil {
private Logger logger = LoggerFactory.getLogger(this.getClass());
@Autowired
private RedisTemplate redisTemplate;
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
public boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 时间(秒) 返回0代表为永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断key是否存在
*
* @param key 键
* @return true 存在 false不存在
*/
public boolean hasKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public void del(String... key) {
if (key != null && key.length > 0) {
if (key.length == 1) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
}
// ============================String=============================
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 递增
*
* @param key 键
* @return
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @return
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, -delta);
}
// ================================Map=================================
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
* @return true 成功 false 失败
*/
public boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmset(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
* @return
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
* @return
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
logger.error("redis error: ", e);
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
logger.error("redis error: ", e);
return 0;
}
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0) {
expire(key, time);
}
return count;
} catch (Exception e) {
logger.error("redis error: ", e);
return 0;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
* @return
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
logger.error("redis error: ", e);
return 0;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
logger.error("redis error: ", e);
return 0;
}
}
// ===============================list=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
* @return
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
logger.error("redis error: ", e);
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
* @return
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
logger.error("redis error: ", e);
return 0;
}
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
* @return
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
logger.error("redis error: ", e);
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
logger.error("redis error: ", e);
return 0;
}
}
// ===============================sorted set=================================
/**
* 向有序集合添加一个成员的
*
* ZADD key score1 member1 [score2 member2]
*
*/
public boolean zadd(String key, Object member, double score, long time) {
try {
redisTemplate.opsForZSet().add(key, member, score);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
logger.error("redis error: ", e);
return false;
}
}
/**
* ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]
通过分数返回有序集合指定区间内的成员
*
*/
public Set<Object> zRangeByScore(String key, double minScore, double maxScore) {
try {
return redisTemplate.opsForZSet().rangeByScore(key, minScore, maxScore);
} catch (Exception e) {
logger.error("redis error: ", e);
return null;
}
}
/**
* ZSCORE key member
返回有序集中，成员的分数值
*
*/
public Double zscore(String key, Object member) {
try {
return redisTemplate.opsForZSet().score(key, member);
} catch (Exception e) {
logger.error("redis error: ", e);
return null;
}
}
/**
* ZRANK key member 返回有序集合中指定成员的索引
*
*/
public Long zrank(String key, Object member) {
try {
return redisTemplate.opsForZSet().rank(key, member);
} catch (Exception e) {
logger.error("redis error: ", e);
return null;
}
}
/**
* Zscan 迭代有序集合中的元素（包括元素成员和元素分值）
*
*/
public Cursor<ZSetOperations.TypedTuple<Object>> zscan(String key) {
try {
Cursor<ZSetOperations.TypedTuple<Object>> cursor = redisTemplate.opsForZSet().scan(key, ScanOptions.NONE);
return cursor;
} catch (Exception e) {
logger.error("redis error: ", e);
return null;
}
}
}
7，结合properties文件。
任务七要求所有的账号和密码都只能通过Spring的配置文件完成。原来邮件test如果是直接写入的，好测试。把这些写死的写入 .properties文件中，然后再测试使用。
比如
mail.smtp.auth = true;
mail.smtp.host = smtp.qq.com;
mail.smtp.port = 465;
#ssl端口
mail.smtp.socketFactory.port = 465;
mail.smtp.socketFactory.fallback = false;
mail.smtp.socketFactory.class = javax.net.ssl.SSLSocketFactory;
我用的是@PropertySource("classpath:mail.properties")。然后加入
@Value("${mail.smtp.auth}")
private String 自定义名字;
这样的语法，比如
@PropertySource("classpath:mail.properties")
public class MailUtil {
private static Logger logger = LoggerFactory.getLogger(MailUtil.class);
@Autowired
private RedisUtil redisUtil;
@Value("${mail.smtp.auth}")
private String auth;
@Value("${mail.smtp.host}")
private String host;
@Value("${mail.smtp.port}")
private String port;
还有可以在spring-mybatis.xml中加入 <context:property-placeholde/>，比如
<context:property-placeholder location="classpath:mail.properties" file-encoding="UTF-8" ignore-unresolvable="true"/>
8，运行，测试前。
按发送邮件按钮填写正确的注册（接收邮件）邮箱后。
运行测试，填写邮箱中验证码后，成功注册一位。为了记录，明文密码是 abcd1234，以后验证登录要用。
二，今天问题
注册需要考虑的问题非常多。很可能需要和运营商量清楚如何去除就是便宜注册，一个人开了5个以上账号，假人来撸毛的。
如果3个以后都可以用，登录的时候选定用户名，要3个都在数据库中查看处理，看看是不是。最后可以收尾到username这个字段上。这个之后的日报再收尾。
三，今天的收获
电子邮件，发送验证码。验证验证码。决定是否能注册。
所以其实这次的表格只有一个，而且属性简单。但是这次的代码，要逻辑写好，不简单。涉及注册可以考虑的地方太多了。
电子邮件部分。
四，明天的计划
任务七。尤其是短信验证注册部分。
返回列表
评论