zoukankan      html  css  js  c++  java

  • 【Spring实战-1】网站登录系统

    系统概述：
    2015年5月8日 14:05:49 
    本系统为一个常规的用户登录系统，主要完成了用户登录界面设计、用户登录后信息校验、更新用户登录信息以及记录用户登录信息等。
    整个系统以Spring框架为基础来实现，项目构架时进行了分层设计，主要包括：持久层、业务层、控制层以及POJO（demain）；
    本系统使用的技术为：
    1. 数据库：MySQL；
    2. 数据库操作：Spring jdbc；
    3. MVC框架，Spring MVC；
    4. 容器：Spring容器；

    涉及到的技术点：
    1.  使用 JdbcTemplate 实现Mysql数据库的增、删、改、查操作；
    2.  注解的使用：
         @Repository：注解持久层（dao）bean；
         @Service：注解业务层bean；
         @Controller：展现层（控制层）bean，标注为Spring mvc的控制器；
         @Autowired：将Spring容器中的bean注入进来；
         @ContextConfiguration：指定Spring配置文件的位置；
         @RequestMapping：指定如何映射请求地址；
    3. RowCallbackHandler：查询结果处理的回调接口，实现ResultSet到POJO对象的转换；
    4. 事务管理器：为数据库操作实现事务；
    5. 引入shema命名空间：
      p: 用于简化类的成员变量；
      tx:
     aop:
    6. 利用junit进行测试；
    7. 配置Spring容器：配置Spring容器所必须的两个参数（web.xml）
    1. <!-- 从类路径下加载Spring配置文件，classpath关键字特指从类路径下加载 -->
    2. 	<context-param>
    3. 		<param-name>contextConfigLocation</param-name>
    4. 		<param-value>classpath:applicationContext.xml</param-value>
    5. 	</context-param>
    6. 	
    7. 	<!-- 负责启动Spring容器的监听器 -->
    8. 	<listener>
    9. 		<listener-class>
    10. 			org.springframework.web.context.ContextLoaderListener
    11. 		</listener-class>
    12. 	</listener>

    8. 配置Spring MVC：（web.xml）
    1.  <!-- 配置Spring MVC，其对应的配置文件为：servlet-name-servlet.xml,
    2.     本项目的为：baobaotao-servlet.xml -->
    3. <servlet>
    4. 		<servlet-name>baobaotao</servlet-name>
    5. 		<servlet-class>
    6. 			org.springframework.web.servlet.DispatcherServlet
    7. 		</servlet-class>
    8. 		<load-on-startup>3</load-on-startup>
    9. 	</servlet>
    11. 	<servlet-mapping>
    12. 		<servlet-name>baobaotao</servlet-name>
    13. 		<url-pattern>*.html</url-pattern>
    14. 	</servlet-mapping>
    9. Spring声明式事务；
    这个以后在具体介绍。
    项目整体布局
    项目整体布局：
     
    主要包括src和test，其中test为junit测试类，主要用于测试业务层；
    使用的jar包
    下面是配置文件及前端界面等；

    Mysql数据库指令
    1. DROP DATABASE IF EXISTS sampledb;
    2. CREATE DATABASE sampledb DEFAULT CHARACTER SET utf8;
    3. USE sampledb;
    5. ##创建用户表
    6. CREATE TABLE t_user (
    7.    user_id   INT AUTO_INCREMENT PRIMARY KEY,
    8.    user_name VARCHAR(30),
    9.    credits INT,
    10.    password  VARCHAR(32),
    11.    last_visit datetime,
    12.    last_ip  VARCHAR(23)
    13. )ENGINE=InnoDB; 
    15. ##创建用户登录日志表
    16. CREATE TABLE t_login_log (
    17.    login_log_id  INT AUTO_INCREMENT PRIMARY KEY,
    18.    user_id   INT,
    19.    ip  VARCHAR(23),
    20.    login_datetime datetime
    21. )ENGINE=InnoDB; 
    23. ##插入初始化数据
    24. INSERT INTO t_user (user_name,password) 
    25.              VALUES('admin','123456');
    26. COMMIT;
    上述指令执行完成后，在Mysql创建的情况如下：


    源程序
    com.baobaotao.domain包：定义POJO对象
    LoginLog.java
    1. package com.baobaotao.domain;
    2. import java.io.Serializable;
    3. import java.util.Date;
    5. public class LoginLog implements Serializable{
    6. 	private int loginLogId;
    8. 	private int userId;
    10. 	private String ip;
    12. 	private Date loginDate;
    14. 	public String getIp() {
    15. 		return ip;
    16. 	}
    18. 	public void setIp(String ip) {
    19. 		this.ip = ip;
    20. 	}
    22. 	public Date getLoginDate() {
    23. 		return loginDate;
    24. 	}
    26. 	public void setLoginDate(Date loginDate) {
    27. 		this.loginDate = loginDate;
    28. 	}
    30. 	public int getLoginLogId() {
    31. 		return loginLogId;
    32. 	}
    34. 	public void setLoginLogId(int loginLogId) {
    35. 		this.loginLogId = loginLogId;
    36. 	}
    38. 	public int getUserId() {
    39. 		return userId;
    40. 	}
    42. 	public void setUserId(int userId) {
    43. 		this.userId = userId;
    44. 	}
    46. }

    User.java
    1. package com.baobaotao.domain;
    3. import java.io.Serializable;
    4. import java.util.Date;
    6. public class User implements Serializable{
    7. 	private int userId;
    9. 	private String userName;
    11. 	private String password;
    13. 	private int credits;
    15. 	private String lastIp;
    17. 	private Date lastVisit;
    19. 	public String getLastIp() {
    20. 		return lastIp;
    21. 	}
    23. 	public void setLastIp(String lastIp) {
    24. 		this.lastIp = lastIp;
    25. 	}
    27. 	public Date getLastVisit() {
    28. 		return lastVisit;
    29. 	}
    31. 	public void setLastVisit(Date lastVisit) {
    32. 		this.lastVisit = lastVisit;
    33. 	}
    35. 	public int getUserId() {
    36. 		return userId;
    37. 	}
    39. 	public void setUserId(int userId) {
    40. 		this.userId = userId;
    41. 	}
    43. 	public String getUserName() {
    44. 		return userName;
    45. 	}
    47. 	public void setUserName(String userName) {
    48. 		this.userName = userName;
    49. 	}
    51. 	public String getPassword() {
    52. 		return password;
    53. 	}
    55. 	public void setPassword(String password) {
    56. 		this.password = password;
    57. 	}
    59. 	public int getCredits() {
    60. 		return credits;
    61. 	}
    63. 	public void setCredits(int credits) {
    64. 		this.credits = credits;
    65. 	}
    66. }
    com.baobaotao.dao包
    LoginLogDao.java
    1. package com.baobaotao.dao;
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.jdbc.core.JdbcTemplate;
    5. import org.springframework.stereotype.Repository;
    7. import com.baobaotao.domain.LoginLog;
    9. @Repository
    10. public class LoginLogDao {
    11. 	@Autowired
    12. 	private JdbcTemplate jdbcTemplate;
    13. 	
    14. 	/**
    15. 	 * 插入登录信息
    16. 	 * @param loginLog
    17. 	 */
    18. 	public void insertLoginLog(LoginLog loginLog) {
    19. 		String sqlStr = "INSERT INTO t_login_log(user_id,ip,login_datetime) "
    20. 				+ "VALUES(?,?,?)";
    21. 		Object[] args = { loginLog.getUserId(), loginLog.getIp(),
    22. 				          loginLog.getLoginDate() };
    23. 		jdbcTemplate.update(sqlStr, args);
    24. 	}
    25. }

    UserDao.java
    1. package com.baobaotao.dao;
    3. import java.sql.ResultSet;
    4. import java.sql.SQLException;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.jdbc.core.JdbcTemplate;
    8. import org.springframework.jdbc.core.RowCallbackHandler;
    9. import org.springframework.stereotype.Repository;
    11. import com.baobaotao.domain.User;
    13. @Repository
    14. public class UserDao {
    15. 	
    16. 	@Autowired
    17. 	private JdbcTemplate jdbcTemplate;
    18. 	
    19. 	/**
    20. 	 * 获取匹配的用户数量
    21. 	 * @param userName
    22. 	 * @param password
    23. 	 * @return
    24. 	 */
    25. 	public int getMatchCount(String userName, String password) {
    26. 		String sqlStr = " SELECT count(*) FROM t_user "
    27. 				+ " WHERE user_name =? and password=? ";
    28. 		return jdbcTemplate.queryForInt(sqlStr, new Object[] { userName, password });
    29. 	}
    31. 	/**
    32. 	 * 查询用户
    33. 	 * @param userName
    34. 	 * @return
    35. 	 */
    36. 	public User findUserByUserName(final String userName) {
    37. 		String sqlStr = " SELECT user_id,user_name,credits "
    38. 				+ " FROM t_user WHERE user_name =? ";
    39. 		final User user = new User();
    40. 		jdbcTemplate.query(sqlStr, new Object[] { userName },
    41. 				new RowCallbackHandler() {
    42. 					public void processRow(ResultSet rs) throws SQLException {
    43. 						user.setUserId(rs.getInt("user_id"));
    44. 						user.setUserName(userName);
    45. 						user.setCredits(rs.getInt("credits"));
    46. 					}
    47. 				});
    48. 		return user;
    49. 	}
    51. 	/**
    52. 	 * 更新登录信息
    53. 	 * @param user
    54. 	 */
    55. 	public void updateLoginInfo(User user) {
    56. 		String sqlStr = " UPDATE t_user SET last_visit=?,last_ip=?,credits=? "
    57. 				+ " WHERE user_id =?";
    58. 		jdbcTemplate.update(sqlStr, new Object[] { user.getLastVisit(),
    59. 				user.getLastIp(),user.getCredits(),user.getUserId()});
    60. 	}
    61. }

    com.baobaotao.service包
    UserService.java
    1. package com.baobaotao.service;
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.stereotype.Service;
    6. import com.baobaotao.dao.LoginLogDao;
    7. import com.baobaotao.dao.UserDao;
    8. import com.baobaotao.domain.LoginLog;
    9. import com.baobaotao.domain.User;
    11. @Service
    12. public class UserService {
    13.     
    14. 	@Autowired
    15. 	private UserDao userDao;
    16. 	
    17. 	@Autowired
    18. 	private LoginLogDao loginLogDao;
    20. 	/**
    21. 	 * 是否有匹配的用户
    22. 	 * @param userName
    23. 	 * @param password
    24. 	 * @return
    25. 	 */
    26. 	public boolean hasMatchUser(String userName, String password) {
    27. 		int matchCount =userDao.getMatchCount(userName, password);
    28. 		return matchCount > 0;
    29. 	}
    30. 	
    31. 	/**
    32. 	 * 根据用户名查找用户
    33. 	 * @param userName
    34. 	 * @return
    35. 	 */
    36. 	public User findUserByUserName(String userName) {
    37. 		return userDao.findUserByUserName(userName);
    38. 	}
    39. 	
    40. 	/**
    41. 	 * 登录成功时，更新登录信息并添加登录记录
    42. 	 * @param user
    43. 	 */
    44. 	public void loginSuccess(User user) {
    45. 		user.setCredits( 5 + user.getCredits()); //信用加5
    46. 		
    47. 		LoginLog loginLog = new LoginLog();
    48. 		loginLog.setUserId(user.getUserId());
    49. 		loginLog.setIp(user.getLastIp());
    50. 		loginLog.setLoginDate(user.getLastVisit());
    51.         userDao.updateLoginInfo(user);
    52.         loginLogDao.insertLoginLog(loginLog);
    53. 	}	
    55. }

    com.baobaotao.web包
    LoginCommand.java
    1. package com.baobaotao.web;
    3. public class LoginCommand {
    4. 	private String userName;
    6. 	private String password;
    8. 	public String getPassword() {
    9. 		return password;
    10. 	}
    12. 	public void setPassword(String password) {
    13. 		this.password = password;
    14. 	}
    16. 	public String getUserName() {
    17. 		return userName;
    18. 	}
    20. 	public void setUserName(String userName) {
    21. 		this.userName = userName;
    22. 	}
    23. }

    LoginController.java
    1. package com.baobaotao.web;
    3. import java.util.Date;
    5. import javax.servlet.http.HttpServletRequest;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.stereotype.Controller;
    10. import org.springframework.web.bind.annotation.RequestMapping;
    11. import org.springframework.web.servlet.ModelAndView;
    13. import com.baobaotao.domain.User;
    14. import com.baobaotao.service.UserService;
    16. @Controller
    17. public class LoginController{
    18. 	
    19. 	@Autowired
    20. 	private UserService userService;
    21.     
    22. 	@RequestMapping(value = "/index.html")
    23. 	public String loginPage(){
    24. 		return "login";
    25. 	}
    26. 	
    27. 	@RequestMapping(value = "/loginCheck.html")
    28. 	public ModelAndView loginCheck(HttpServletRequest request,LoginCommand loginCommand){
    29. 		boolean isValidUser = 
    30. 			   userService.hasMatchUser(loginCommand.getUserName(),
    31. 					                    loginCommand.getPassword());
    32. 		if (!isValidUser) {
    33. 			return new ModelAndView("login", "error", "用户名或密码错误。");
    34. 		} else {
    35. 			User user = userService.findUserByUserName(loginCommand
    36. 					.getUserName());
    37. 			user.setLastIp(request.getLocalAddr());
    38. 			user.setLastVisit(new Date());
    39. 			userService.loginSuccess(user);
    40. 			request.getSession().setAttribute("user", user);
    41. 			return new ModelAndView("main");
    42. 		}
    43. 	}
    44. }
    说明：
    在mvc架构中，model和view是松耦合的，控制层负责产生model数据，而view负责渲染模型数据。
    request.getSession().setAttribute("user", user);
    return new ModelAndView("main");
    等价于：
    ModelAndView("main", "user", user);


    web.xml
    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <web-app version="2.5" 
    3. 	xmlns="http://java.sun.com/xml/ns/javaee" 
    4. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    5. 	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    6. 	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    7. 	
    8. 	<!-- 从类路径下加载Spring配置文件，classpath关键字特指从类路径下加载 -->
    9. 	<context-param>
    10. 		<param-name>contextConfigLocation</param-name>
    11. 		<param-value>classpath:applicationContext.xml</param-value>
    12. 	</context-param>
    13. 	
    14. 	<!-- 负责启动Spring容器的监听器 -->
    15. 	<listener>
    16. 		<listener-class>
    17. 			org.springframework.web.context.ContextLoaderListener
    18. 		</listener-class>
    19. 	</listener>
    21.    <!-- 配置Spring MVC，其对应的配置文件为：servlet-name-servlet.xml,
    22.     本项目的为：baobaotao-servlet.xml -->
    23. 	<servlet>
    24. 		<servlet-name>baobaotao</servlet-name>
    25. 		<servlet-class>
    26. 			org.springframework.web.servlet.DispatcherServlet
    27. 		</servlet-class>
    28. 		<load-on-startup>3</load-on-startup>
    29. 	</servlet>
    31. 	<servlet-mapping>
    32. 		<servlet-name>baobaotao</servlet-name>
    33. 		<url-pattern>*.html</url-pattern>
    34. 	</servlet-mapping>
    35. </web-app>
    说明：
    web.xml中，contextConfigLocation和ContextLoaderListener是使用Spring容器必须配置的；
    而DispatcherServlet是使用Spring MVC所必须的。



    Spring配置文件
    applicationContext.xml
    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    4. 	xmlns:context="http://www.springframework.org/schema/context"
    5. 	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    6. 	xsi:schemaLocation="http://www.springframework.org/schema/beans 
    7.        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    8.        http://www.springframework.org/schema/context 
    9.        http://www.springframework.org/schema/context/spring-context-3.0.xsd
    10.        http://www.springframework.org/schema/tx 
    11.        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    12.        http://www.springframework.org/schema/aop
    13.        http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
    14.     
    15.     <!-- 扫描类包，将标注Spring注解的类自动转化Bean，同时完成Bean的注入 -->
    16.     <context:component-scan base-package="com.baobaotao.dao"/>
    17.     <context:component-scan base-package="com.baobaotao.service"/>
    19.     <!-- 配置数据源 -->
    20. 	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
    21. 		destroy-method="close" 
    22. 		p:driverClassName="com.mysql.jdbc.Driver"
    23. 		p:url="jdbc:mysql://localhost:3306/sampledb" 
    24. 		p:username="root"
    25. 		p:password="xxx" />
    27. 	<!-- 配置Jdbc模板  -->
    28. 	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
    29. 		p:dataSource-ref="dataSource" />
    30. 		
    31. 	<!-- 配置事务管理器 -->
    32. 	<bean id="transactionManager"
    33. 		class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
    34. 		p:dataSource-ref="dataSource" />
    35. 		
    36. 	<!-- 通过AOP配置提供事务增强，让service包下所有Bean的所有方法拥有事务 -->
    37. 	<aop:config proxy-target-class="true">
    38. 		<aop:pointcut id="serviceMethod"
    39. 			expression=" execution(* com.baobaotao.service..*(..))" />
    40. 		<aop:advisor pointcut-ref="serviceMethod" advice-ref="txAdvice" />
    41. 	</aop:config>
    42. 	
    43. 	<tx:advice id="txAdvice" transaction-manager="transactionManager">
    44. 		<tx:attributes>
    45. 			<tx:method name="*" />
    46. 		</tx:attributes>
    47. 	</tx:advice>
    48. </beans>
    说明：
    上述配置文件中，使用了schema来简化配置。如：<p:...>、<tx:...>、<aop:...>;
    组件扫描：<context:component>扫描标记了@Controller、@Service、@Repository的类，自动为这些类创建bean。

    Spring MVC配置文件
    baobaotao-servlet.xml
    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3. 	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    4. 	xmlns:context="http://www.springframework.org/schema/context"
    5. 	xsi:schemaLocation="http://www.springframework.org/schema/beans
    6.        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    7.        http://www.springframework.org/schema/context 
    8.        http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    9. 	<!-- 扫描web包，应用Spring的注解 -->
    10. 	<context:component-scan base-package="com.baobaotao.web"/>
    11. 	
    12. 	<!-- 配置视图解析器，将ModelAndView及字符串解析为具体的页面 -->
    13. 	<bean
    14. 		class="org.springframework.web.servlet.view.InternalResourceViewResolver"
    15. 		p:viewClass="org.springframework.web.servlet.view.JstlView" 
    16. 		p:prefix="/WEB-INF/jsp/"
    17. 		p:suffix=".jsp" />
    19. </beans>
    说明：
    这是配置了InternalResourceViewResolver视图解析器。Spring MVC中的视图解析器有好多种，且每种视图解析器都可以设置优先级。InternalResourceViewResolver视图解析器只是最常用且最普通的一种视图解析器，它的默认优先级是最低的。


    前端jsp界面
    login.jsp
    1. <%@ page language="java" contentType="text/html; charset=UTF-8"
    2. 	pageEncoding="UTF-8"%>
    3. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
    4. <html>
    5. 	<head>
    6. 		<title>论坛登录</title>
    7. 	</head>
    8. 	<body>
    9. 		<c:if test="${!empty error}">
    10. 	        <font color="red"><c:out value="${error}" /></font>
    11. 		</c:if>        
    12. 		<form action="<c:url value="loginCheck.html"/>" method="post">
    13. 			用户名：
    14. 			<input type="text" name="userName">
    15. 			<br>
    16. 			密 码：
    17. 			<input type="password" name="password">
    18. 			<br>
    19. 			<input type="submit" value="登录" />
    20. 			<input type="reset" value="重置" />
    21. 		</form>
    22. 	</body>
    23. </html>
    说明：
    这里使用了jstl标签，<c:url value="loginCheck.html"/>的jstl标签会在url前自动加上应用程序的部署根目录，假设应用程序部署在bbt目录下，<c:url/>标签将输出：/bbt/loginCheck.html 。通过<c:url />标签，很好的解决了开发和应用部署目录不一致的问题。
    main.jsp
    1. <%@ page language="java" contentType="text/html; charset=UTF-8"
    2.     pageEncoding="UTF-8"%>
    3. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
    4. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    5. <html>
    6. <head>
    7. <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
    8. <title>论坛</title>
    9. </head>
    10. <body>
    11.     ${user.userName},欢迎您进入宝宝淘论坛，您当前积分为${user.credits};
    12. </body>
    13. </html>

    log4j.properties
    1. log4j.rootLogger=DEBUG,A1
    2. log4j.appender.A1=org.apache.log4j.ConsoleAppender
    3. log4j.appender.A1.layout=org.apache.log4j.PatternLayout
    4. log4j.appender.A1.layout.ConversionPattern=%d %5p [%t] (%F:%L) - %m%n
    程序测试
    在tomcat下运行该系统，在浏览器中输入：http://localhost:8080/LoginProj/loginCheck.html ，
    用户名密码输入错误时：

    用户名密码输入正确时：

    下面是数据库信息：



    Junit测试
    com.baobaotao.service包：TestUserService.java
    1. package com.baobaotao.service;
    3. import static org.junit.Assert.*;
    5. import java.util.Date;
    8. import org.junit.Test;
    9. import org.junit.runner.RunWith;
    10. import org.springframework.beans.factory.annotation.Autowired;
    11. import org.springframework.test.context.ContextConfiguration;
    12. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    14. import com.baobaotao.domain.User;
    16. @RunWith(SpringJUnit4ClassRunner.class)
    17. @ContextConfiguration(locations={"classpath:applicationContext.xml"})
    18. public class TestUserService {
    20. 	@Autowired
    21.     private UserService userService;
    23. 	@Test
    24. 	public void testHasMatchUser() {
    25. 		boolean b1 = userService.hasMatchUser("admin", "123456");
    26. 		boolean b2 = userService.hasMatchUser("admin", "1111");
    27. 		assertTrue(b1);
    28. 		assertTrue(!b2);
    29. 	}
    31. 	@Test
    32. 	public void testFindUserByUserName() {
    33. 		User user = userService.findUserByUserName("admin");
    34. 		assertEquals(user.getUserName(), "admin");
    35. 	}
    37. 	@Test
    38. 	public void testAddLoginLog() {
    39. 		User user = userService.findUserByUserName("admin");
    40. 		user.setUserId(1);
    41. 		user.setUserName("admin");
    42. 		user.setLastIp("192.168.12.7");
    43. 		user.setLastVisit(new Date());
    44. 		userService.loginSuccess(user);
    45. 	}
    46. }
    测试结果如下：


    至此，整个系统全部完成。












    附件列表
    • 相关阅读:
      python学习===从一个数中分解出每个数字
      python学习===复制list
      Jmeter===测试案例参考
      Jmeter==HTTP信息头管理器的作用
      python实战===使用随机的163账号发送邮件
      python实战===实现读取txt每一行的操作，账号密码
      python实战===生成随机数
      python实战===输入密码以******的形式在cmd中展示
      python实战===使用smtp发送邮件的源代码，解决554错误码的问题，更新版！
      python实战===使用smtp发送邮件的源代码，解决554错误码的问题
    • 原文地址：https://www.cnblogs.com/ssslinppp/p/4487552.html
    Copyright © 2011-2022 走看看