springemail区块链
❶ 用spring发送带有中文的邮件主题和内容，邮件接收后总是被编码过的，怎么解决
先来看看发送Email吧, 在Spring中发送Email是很简单的,使用Spring提高的MailSender和MailMessage就可以了,配置代码如下: smtp.163.com true 你的Email地址 你的Email密码 收件人地址 你的地址 A Spring Mail sender 上面的配置好以后就可以直接...
❷ 如何用Spring来发邮件
先来看看发送Email吧, 在Spring中发送Email是很简单的,使用Spring提高的MailSender和MailMessage就可以了,配置代码如下:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "spring-beans.dtd" >
<beans>
<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
<property name="host">
<value>smtp.163.com</value>
</property>
<property name="javaMailProperties">
<props>
<!-- 如果要使用用户名和密码验证,这一步需要 -->
<prop key="mail.smtp.auth">true</prop>
</props>
</property>
<property name="username">
<value>你的Email地址</value>
</property>
<property name="password">
<value>你的Email密码</value>
</property>
</bean>
<!-- 简单的message -->
<bean id="mailMessage" class="org.springframework.mail.SimpleMailMessage">
<property name="to">
<value>收件人地址</value>
</property>
<property name="from">
<value>你的地址</value>
</property>
<property name="subject"> <!-- Email 标题 -->
<value>A Spring Mail sender</value>
</property>
</bean>
<!-- 测试发送的类 -->
<bean id="testMailSender" class="test.mail.TestSenderMail">
<property name="mailMessage">
<ref bean="mailMessage"/>
</property>
<property name="mailSender">
<ref bean="mailSender"/>
</property>
</bean>
</beans>
上面的配置好以后就可以直接发送了, 看看TestSenderMail.java的代码:
package test.mail;
import org.springframework.mail.MailException;
import org.springframework.mail.MailSender;
import org.springframework.mail.SimpleMailMessage;
public class TestSenderMail {
private MailSender mailSender;
private SimpleMailMessage mailMessage;
public TestSenderMail() { }
public SimpleMailMessage getMailMessage() {
return mailMessage; }
public void setMailMessage(SimpleMailMessage mailMessage) {
this.mailMessage = mailMessage; }
public MailSender getMailSender() {
return mailSender; }
public void setMailSender(MailSender mailSender) {
this.mailSender = mailSender; }
public void sendMail() {
SimpleMailMessage message = new SimpleMailMessage(mailMessage); //设置email内容,
message.setText("测试Spring 发送Email.");
try {
mailSender.send(message);
} catch (MailException e) {
System.out.println("O . 发送Email失败了....");
e.printStackTrace();
}
}
}
很简单吧. 下面是测试类: TestApp.java
package test.mail;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.;
public class TestApp {
public static void main(String[] args) {
ApplicationContext context = new ( "test/mail/mail.xml");
TestSenderMail sender = (TestSenderMail) context .getBean("testMailSender");
sender.sendMail();
}
//抛出如下异常,是瑞星监控的问题,关闭就可以了
/** * DEBUG SMTP: QUIT failed with 250 O . 发送Email失败了....
* org.springframework.mail.MailSendException: Could not send mails: 354
* * com.sun.mail.smtp.SMTPSendFailedException: 354 * * at * com.sun.mail.smtp.SMTPTransport.issueSendCommand(SMTPTransport.java:1388) * at com.sun.mail.smtp.SMTPTransport.finishData(SMTPTransport.java:1215) at * com.sun.mail.smtp.SMTPTransport.sendMessage(SMTPTransport.java:586) */
}
呵呵, 现在就可以发送Email了.
最后提醒一下，记得要将：activation.jar 和 mail.jar 两个包导入到工程
❸ 用spring的email抽象层发送邮件时报错，求指点
估计你是没有导入mail.jar或者说是javamail.jar到你的buildpath里面。参见:http://stackoverflow.com/questions/6743031/how-to-resolve-javax-mail-messagingexception
❹ 谈谈spring是如何实现的
Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。
在这篇由三部分组成的 Spring 系列 的第 1 部分中，我将介绍 Spring 框架。我先从框架底层模型的角度描述该框架的功能，然后将讨论两个最有趣的模块：Spring 面向方面编程（AOP）和控制反转 （IOC） 容器。接着将使用几个示例演示 IOC 容器在典型应用程序用例场景中的应用情况。这些示例还将成为本系列后面部分进行的展开式讨论的基础，在本文的后面部分，将介绍 Spring 框架通过 Spring AOP 实现 AOP 构造的方式。
请参阅 下载，下载 Spring 框架和 Apache Ant，运行本系列的示例应用程序需要它们。
Spring 框架
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所示。
图 1. Spring 框架的 7 个模块
Spring 框架图示
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：
* 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
* Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
* Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
* Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
* Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
* Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
* Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。
Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、测试环境之间重用。
回页首
IOC 和 AOP
控制反转模式（也称作依赖性介入）的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器 （在 Spring 框架中是 IOC 容器） 负责将这些联系在一起。
在典型的 IOC 场景中，容器创建了所有对象，并设置必要的属性将它们连接在一起，决定什么时间调用方法。下表列出了 IOC 的一个实现模式。
类型 1 服务需要实现专门的接口，通过接口，由对象提供这些服务，可以从对象查询依赖性（例如，需要的附加服务）
类型 2 通过 JavaBean 的属性（例如 setter 方法）分配依赖性
类型 3 依赖性以构造函数的形式提供，不以 JavaBean 属性的形式公开
Spring 框架的 IOC 容器采用类型 2 和类型3 实现。
面向方面的编程
面向方面的编程，即 AOP，是一种编程技术，它允许程序员对横切关注点或横切典型的职责分界线的行为（例如日志和事务管理）进行模块化。AOP 的核心构造是方面，它将那些影响多个类的行为封装到可重用的模块中。
AOP 和 IOC 是补充性的技术，它们都运用模块化方式解决企业应用程序开发中的复杂问题。在典型的面向对象开发方式中，可能要将日志记录语句放在所有方法和 Java 类中才能实现日志功能。在 AOP 方式中，可以反过来将日志服务模块化，并以声明的方式将它们应用到需要日志的组件上。当然，优势就是 Java 类不需要知道日志服务的存在，也不需要考虑相关的代码。所以，用 Spring AOP 编写的应用程序代码是松散耦合的。
AOP 的功能完全集成到了 Spring 事务管理、日志和其他各种特性的上下文中。
回页首
IOC 容器
Spring 设计的核心是 org.springframework.beans 包，它的设计目标是与 JavaBean 组件一起使用。这个包通常不是由用户直接使用，而是由服务器将其用作其他多数功能的底层中介。下一个最高级抽象是 BeanFactory 接口，它是工厂设计模式的实现，允许通过名称创建和检索对象。BeanFactory 也可以管理对象之间的关系。
BeanFactory 支持两个对象模型。
* 单态 模型提供了具有特定名称的对象的共享实例，可以在查询时对其进行检索。Singleton 是默认的也是最常用的对象模型。对于无状态服务对象很理想。
* 原型 模型确保每次检索都会创建单独的对象。在每个用户都需要自己的对象时，原型模型最适合。
bean 工厂的概念是 Spring 作为 IOC 容器的基础。IOC 将处理事情的责任从应用程序代码转移到框架。正如我将在下一个示例中演示的那样，Spring 框架使用 JavaBean 属性和配置数据来指出必须设置的依赖关系。
BeanFactory 接口
因为 org.springframework.beans.factory.BeanFactory 是一个简单接口，所以可以针对各种底层存储方法实现。最常用的 BeanFactory 定义是 XmlBeanFactory，它根据 XML 文件中的定义装入 bean，如清单 1 所示。
清单 1. XmlBeanFactory
BeanFactory factory = new XMLBeanFactory(new FileInputSteam("mybean.xml"));
在 XML 文件中定义的 Bean 是被消极加载的，这意味在需要 bean 之前，bean 本身不会被初始化。要从 BeanFactory 检索 bean，只需调用 getBean() 方法，传入将要检索的 bean 的名称即可，如清单 2 所示。
清单 2. getBean()
MyBean mybean = (MyBean) factory.getBean("mybean");
每个 bean 的定义都可以是 POJO （用类名和 JavaBean 初始化属性定义） 或 FactoryBean。FactoryBean 接口为使用 Spring 框架构建的应用程序添加了一个间接的级别。
回页首
IOC 示例
理解控制反转最简单的方式就是看它的实际应用。在对由三部分组成的 Spring 系列 的第 1 部分进行总结时，我使用了一个示例，演示了如何通过 Spring IOC 容器注入应用程序的依赖关系（而不是将它们构建进来）。
我用开启在线信用帐户的用例作为起点。对于该实现，开启信用帐户要求用户与以下服务进行交互：
* 信用级别评定服务，查询用户的信用历史信息。
* 远程信息链接服务，插入客户信息，将客户信息与信用卡和银行信息连接起来，以进行自动借记（如果需要的话）。
* 电子邮件服务，向用户发送有关信用卡状态的电子邮件。
回页首
三个接口
对于这个示例，我假设服务已经存在，理想的情况是用松散耦合的方式把它们集成在一起。以下清单显示了三个服务的应用程序接口。
清单 3. CreditRatingInterface
public interface CreditRatingInterface {
public boolean (ICustomer iCustomer);
}
清单 3 所示的信用级别评定接口提供了信用历史信息。它需要一个包含客户信息的 Customer 对象。该接口的实现是由 CreditRating 类提供的。
清单 4. CreditLinkingInterface
public interface CreditLinkingInterface {
public String getUrl();
public void setUrl(String url);
public void linkCreditBankAccount() throws Exception ;
}
信用链接接口将信用历史信息与银行信息（如果需要的话）连接在一起，并插入用户的信用卡信息。信用链接接口是一个远程服务，它的查询是通过 getUrl() 方法进行的。URL 由 Spring 框架的 bean 配置机制设置，我稍后会讨论它。该接口的实现是由 CreditLinking 类提供的。
清单 5. EmailInterface
public interface EmailInterface {
public void sendEmail(ICustomer iCustomer);
public String getFromEmail();
public void setFromEmail(String fromEmail) ;
public String getPassword();
public void setPassword(String password) ;
public String getSmtpHost() ;
public void setSmtpHost(String smtpHost);
public String getUserId() ;
public void setUserId(String userId);
}
EmailInterface 负责向客户发送关于客户信用卡状态的电子邮件。邮件配置参数（例如 SMPT 主机、用户名、口令）由前面提到的 bean 配置机制设置。Email 类提供了该接口的实现。
回页首
Spring 使其保持松散
这些接口就位之后，接下来要考虑的就是如何用松散耦合方式将它们集成在一起。在 清单 6 中可以看到信用卡帐户用例的实现。
注意，所有的 setter 方法都是由 Spring 的配置 bean 实现的。所有的依赖关系 （也就是三个接口）都可以由 Spring 框架用这些 bean 注入。createCreditCardAccount() 方法会用服务去执行其余实现。在 清单 7 中可以看到 Spring 的配置文件。我用箭头突出了这些定义。
回页首
运行应用程序
要运行示例应用程序，首先必须 下载 Spring 框架 及其所有依赖文件。接下来，将框架释放到（比如说）磁盘 c:\，这会创建 C:\spring-framework-1.2-rc2 （适用于当前发行版本） 这样的文件夹。在继续后面的操作之前，还必须下载和释放 Apache Ant。
接下来，将源代码释放到文件夹，例如 c:\ 盘，然后创建 SpringProject。将 Spring 库（即 C:\spring-framework-1.2-rc2\dist 下的 spring.jar 和 C:\spring-framework-1.2-rc2\lib\jakarta-commons 下的 commons-logging.jar）复制到 SpringProject\lib 文件夹中。完成这些工作之后，就有了必需的构建依赖关系集。
打开命令提示符，将当前目录切换到 SpringProject，在命令提示符中输入以下命令：build。
这会构建并运行 CreateCreditAccountClient 类，类的运行将创建 Customer 类对象并填充它，还会调用 CreateCreditCardAccount 类创建并链接信用卡帐户。CreateCreditAccountClient 还会通过 装入 Spring 配置文件。装入 bean 之后，就可以通过 getBean() 方法访问它们了，如清单 8 所示。
清单 8. 装入 Spring 配置文件
appContext =
new (new String[] {
"springexample-creditaccount.xml"
});
creditCardAccount =
()
appContext.getBean("createCreditCard");
回页首
结束语
在这篇由三部分组成的 Spring 系列 的第一篇文章中，我介绍了 Spring 框架的基础。我从讨论组成 Spring 分层架构的 7 个模块开始，然后深入介绍了其中两个模块：Spring AOP 和 IOC 容器。
由于学习的最佳方法是实践，所以我用一个工作示例介绍了 IOC 模式 （像 Spring 的 IOC 容器实现的那样）如何用松散耦合的方式将分散的系统集成在一起。在这个示例中可以看到，将依赖关系或服务注入工作中的信用卡帐户应用程序，要比从头开始构建它们容易得多。
❺ javax.mail和spring mail的区别
javax.mail:
package com.healist.email;
import javax.mail.*;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import java.util.Properties;
/**
* Created by Healist on 2017/1/29.
*/
public class Email {
public static void main(String[] args) throws MessagingException {
// 创建Properties 类用于记录邮箱的一些属性
Properties props = new Properties();
// 表示SMTP发送邮件，必须进行身份验证
props.put("mail.smtp.auth", "true");
//此处填写SMTP服务器
props.put("mail.smtp.host", "smtp.qq.com");
//端口号，QQ邮箱给出了两个端口，但是另一个不管用，这个587在这是管用的
props.put("mail.smtp.port", "587");
// 此处填写你的账号
props.put("mail.user", "[email protected]");
// QQ邮箱的授权码，去邮箱自己获取
props.put("mail.password", "dffajaehrb");
// 构建授权信息，用于进行SMTP进行身份验证
Authenticator authenticator = new Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
// 用户名、密码
String userName = props.getProperty("mail.user");
String password = props.getProperty("mail.password");
return new PasswordAuthentication(userName, password);
}
};
// 使用环境属性和授权信息，创建邮件会话
Session mailSession = Session.getInstance(props, authenticator);
// 创建邮件消息
MimeMessage message = new MimeMessage(mailSession);
// 设置发件人
InternetAddress form = new InternetAddress(
props.getProperty("mail.user"));
message.setFrom(form);
// 设置收件人的邮箱
InternetAddress to = new InternetAddress("[email protected]");
message.setRecipient(MimeMessage.RecipientType.TO, to);
// 设置邮件标题
message.setSubject("测试邮件");
// 设置邮件的内容体
message.setContent("这是一封测试邮件", "text/html;charset=UTF-8");
// 发送邮件
Transport.send(message);
}
}
Spring Mail:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">
<context:component-scan base-package="com.healist.*">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
<context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice" />
</context:component-scan>
<!-- 引入配置文件 -->
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:dev.properties</value>
<!--如果有多个配置文件，在这里继续添加 -->
</list>
</property>
</bean>
<bean id="javaMailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
<property name="host" value="${mail.smtp.host}" />
<property name="port" value="${mail.smtp.port}" />
<property name="username" value="${mail.smtp.username}" />
<property name="password" value="${mail.smtp.password}" />
<property name="javaMailProperties">
<props>
<prop key="mail.smtp.timeout">${mail.smtp.timeout}</prop>
<prop key="mail.smtp.auth">${mail.smtp.auth}</prop>
<prop key="mail.smtp.starttls.enable">${mail.smtp.starttls.enable}</prop>
<prop key="mail.smtp.socketFactory.port">${mail.smtp.port}</prop>
<prop key="mail.smtp.socketFactory.class">javax.net.ssl.SSLSocketFactory</prop>
<prop key="mail.smtp.socketFactory.fallback">false</prop>
</props>
</property>
</bean>
<tx:annotation-driven />
</beans>
❻ 关于java Spring Mail中host参数设置问题
是smtp服务器的地址，去相应的邮件服务商的网页，找outlook设定的内容，其中就有smtp服务器地址的记载。
例如，使用gmail的话是smtp.gmail.com
❼ spring源码怎么读
在我们的生活之中，有形形色色的万物（Object）,有飞机，有汽车，有轮船，还有我这个沧海一粟的java讲师。
试问：了解飞机底层架构的人，就一定能把飞机开好吗？精通汽车的构造和底层原理的人，就保证开车不出事故吗？或者反过来问，一个多年的开出租车的老司机，技术非常娴熟，但是你问他汽车的架构和底层原理，你觉得有多少老司机能准确的答出来？
那就对了，了解了，读懂了spring底层源码的程序员，我们并不能保证他就是一个好程序员，我心中的一个好的程序员是要能够提出解决方案的程序员，就好比清华北大确实只是个过程，最后的目的，是为国家为人民做出奉献才是我们活着的价值。所以说我并不看好去阅读spring源码这个行为。闻道有先后，术业有专攻，我们不是提供底层技术的人！绝大多数的程序员，我以为正确的做法是站在巨人的肩膀上，把前辈留下来的精髓发扬光大才是正道，简而言之，把怎么用，和为什么要这么用学好才是大多数程序员学习技术的关键。就好比去学驾照的时候，教练只需要关心你是否会开车，是否遵守交通规则，并不关心你是否了解汽车是如何在路上跑起来的。
一个人的精力和时间都是有限的，分细了来说，开发者就是技术的使用者，重点在于如何正确熟练的使用，而不是一昧地去关心底层原理，如果要完全读懂spring源码，首先，英语就得很厉害吧，其次，得花多少时间？就算读懂了，那收获和付出也不成正比，大把大把的时间为何不花在java更多，更高级，更有意义的技术上呢？笔者此话并不是说spring源码读了没用，只是让我们的时间更有价值，例如分布式微服务，区块链技术，大数据，python，作为新时代的IT佼佼者，我们是否应该随着时代的脚步，迎接崭新的未来？我奉劝大多数人，不必去看spring源码，除非你确实感兴趣作为技术研究，这样是可以的。一个正常的工作者，是不建议花宝贵的时间去看的，那学生就更不应该去看了。此话怎讲？我以为，学生应以学业为重，士不可不弘毅，任重而道远，首先应该扩展其知识的广度，和技术的娴熟使用，再培养学生独立解决问题的能力，沟通协作的能力，最后才考虑技术的深度。
笔者在多年前也被面试过很多很多问题，但是从来没有一个面试官会问spring底层源码，曾经阿里巴巴的架构师也面试过我，直到后来，我成为了面试官，当我去面试别人的时候，我也不会去问spring源码这些东西，因为99.9%企业招人进来，是要做事实的，不是让你去研究一个技术，绝大多数更在乎的是利用现有的技术，去完成一些项目功能。除了世界上极少数著名的企业他们需要技术研究员，才对这些有所要求，那要招这类人才，估计至少也是名校研究生以上吧，所以普通程序开发者，我觉得学好技术的正确与熟练使用，才是重中之重！
不宜本末倒置，不宜好高骛远。笔者从事Java行业以来，真要说全阶段全程全栈都精通的人，应属风毛菱角，故此，更应让所学知识运筹帷幄，举一反三，千里炉火，万里纯青。以上篇幅在说我对阅读spring源码的一些强烈建议，最终结论，是不看、不读就此作罢。
那有的感兴趣的人非要阅读呢？
Ok,其实阅读spring源码并不算很难。
首先，应该去官网spring.io阅读写spring框架的理念，就好比读一本书，要阅读这本书的纲要，要明白为什么要设计spring架构。
然后，应该分模块阅读，先从核心模块开始阅读：如：
IoC Container, Events, Resources, i18n, Validation, Data Binding, Type Conversion, SpEL, AOP.
那么在阅读的时候，英文能力差的话，可以使用翻译软件翻译成中文阅读，毕竟不是每个程序员英语都很棒，毕竟中国人看中国字更容易去理解。当然，有些翻译过来的并不准确，这个时候可以利用网络，去查看那段不理解的地方。
然后，把spring的jar包下载下来，利用IDEA打开，可以使用download资源，会发现，每个方法上面都会有详细的英文注释。一边看官方的说明，一边查看代码的编写，不难发现，非常多的代码写得很精辟，所以十分考验一个程序员的java基本功，特别是反射，JDK\CGLIB代理，和java常用的设计模式等。