少年阿宾

那些青春的岁月

:: 管理

500 Posts :: 0 Stories :: 135 Comments :: 0 Trackbacks

在上网的时候，我们经常会看到“端口”这个词，也会经常用到端口号，比如在FTP地址后面增加的“21”，21就表示端口号。那么端口到底是什么意思呢？怎样查看端口号呢？一个端口是否成为网络恶意攻击的大门呢？，我们应该如何面对形形色色的端口呢？下面就将介绍这方面的内容,以供大家参考。

21端口：21端口主要用于FTP（File Transfer Protocol，文件传输协议）服务。

端口说明：21端口主要用于FTP（File Transfer Protocol，文件传输协议）服务，FTP服务主要是为了在两台计算机之间实现文件的上传与下载，一台计算机作为FTP客户端，另一台计算机作为FTP服务器，可以采用匿名（anonymous）登录和授权用户名与密码登录两种方式登录FTP服务器。目前，通过FTP服务来实现文件的传输是互联网上上传、下载文件最主要的方法。另外，还有一个20端口是用于FTP数据传输的默认端口号。

在Windows中可以通过Internet信息服务（IIS）来提供FTP连接和管理，也可以单独安装FTP服务器软件来实现FTP功能，比如常见的FTP Serv-U。

操作建议：因为有的FTP服务器可以通过匿名登录，所以常常会被黑客利用。另外，21端口还会被一些木马利用，比如Blade Runner、FTP Trojan、Doly Trojan、WebEx等等。如果不架设FTP服务器，建议关闭21端口。

23端口：23端口主要用于Telnet（远程登录）服务，是Internet上普遍采用的登录和仿真程序。

端口说明：23端口主要用于Telnet（远程登录）服务，是Internet上普遍采用的登录和仿真程序。同样需要设置客户端和服务器端，开启Telnet服务的客户端就可以登录远程Telnet服务器，采用授权用户名和密码登录。登录之后，允许用户使用命令提示符窗口进行相应的操作。在Windows中可以在命令提示符窗口中，键入“Telnet”命令来使用Telnet远程登录。

操作建议：利用Telnet服务，黑客可以搜索远程登录Unix的服务，扫描操作系统的类型。而且在Windows 2000中Telnet服务存在多个严重的漏洞，比如提升权限、拒绝服务等，可以让远程服务器崩溃。Telnet服务的23端口也是TTS（Tiny Telnet Server）木马的缺省端口。所以，建议关闭23端口。

25端口：25端口为SMTP（Simple Mail Transfer Protocol，简单邮件传输协议）服务器所开放，主要用于发送邮件，如今绝大多数邮件服务器都使用该协议。

端口说明：25端口为SMTP（Simple Mail Transfer Protocol，简单邮件传输协议）服务器所开放，主要用于发送邮件，如今绝大多数邮件服务器都使用该协议。比如我们在使用电子邮件客户端程序的时候，在创建账户时会要求输入SMTP服务器地址，该服务器地址默认情况下使用的就是25端口。

端口漏洞：

1. 利用25端口，黑客可以寻找SMTP服务器，用来转发垃圾邮件。

2. 25端口被很多木马程序所开放，比如Ajan、Antigen、Email Password Sender、ProMail、trojan、Tapiras、Terminator、WinPC、WinSpy等等。拿WinSpy来说，通过开放25端口，可以监视计算机正在运行的所有窗口和模块。

操作建议：如果不是要架设SMTP邮件服务器，可以将该端口关闭。

53端口：53端口为DNS（Domain Name Server，域名服务器）服务器所开放，主要用于域名解析，DNS服务在NT系统中使用的最为广泛。

端口说明：53端口为DNS（Domain Name Server，域名服务器）服务器所开放，主要用于域名解析，DNS服务在NT系统中使用的最为广泛。通过DNS服务器可以实现域名与IP地址之间的转换，只要记住域名就可以快速访问网站。

端口漏洞：如果开放DNS服务，黑客可以通过分析DNS服务器而直接获取Web服务器等主机的IP地址，再利用53端口突破某些不稳定的防火墙，从而实施攻击。近日，美国一家公司也公布了10个最易遭黑客攻击的漏洞，其中第一位的就是DNS服务器的BIND漏洞。

操作建议：如果当前的计算机不是用于提供域名解析服务，建议关闭该端口。

67、68端口：67、68端口分别是为Bootp服务的Bootstrap Protocol Server（引导程序协议服务端）和Bootstrap Protocol Client（引导程序协议客户端）开放的端口。

端口说明：67、68端口分别是为Bootp服务的Bootstrap Protocol Server（引导程序协议服务端）和Bootstrap Protocol Client（引导程序协议客户端）开放的端口。Bootp服务是一种产生于早期Unix的远程启动协议，我们现在经常用到的DHCP服务就是从Bootp服务扩展而来的。通过Bootp服务可以为局域网中的计算机动态分配IP地址，而不需要每个用户去设置静态IP地址。

端口漏洞：如果开放Bootp服务，常常会被黑客利用分配的一个IP地址作为局部路由器通过“中间人”（man-in-middle）方式进行攻击。

操作建议：建议关闭该端口。

69端口：TFTP是Cisco公司开发的一个简单文件传输协议，类似于FTP。

端口说明：69端口是为TFTP（Trival File Tranfer Protocol，次要文件传输协议）服务开放的，TFTP是Cisco公司开发的一个简单文件传输协议，类似于FTP。不过与FTP相比，TFTP不具有复杂的交互存取接口和认证控制，该服务适用于不需要复杂交换环境的客户端和服务器之间进行数据传输。

端口漏洞：很多服务器和Bootp服务一起提供TFTP服务，主要用于从系统下载启动代码。可是，因为TFTP服务可以在系统中写入文件，而且黑客还可以利用TFTP的错误配置来从系统获取任何文件。

操作建议：建议关闭该端口。

79端口：79端口是为Finger服务开放的，主要用于查询远程主机在线用户、操作系统类型以及是否缓冲区溢出等用户的详细信息。

端口说明：79端口是为Finger服务开放的，主要用于查询远程主机在线用户、操作系统类型以及是否缓冲区溢出等用户的详细信息。比如要显示远程计算机www.abc.com上的user01用户的信息，可以在命令行中键入“finger user01@www.abc.com”即可。

端口漏洞：一般黑客要攻击对方的计算机，都是通过相应的端口扫描工具来获得相关信息，比如使用“流光”就可以利用79端口来扫描远程计算机操作系统版本，获得用户信息，还能探测已知的缓冲区溢出错误。这样，就容易遭遇到黑客的攻击。而且，79端口还被Firehotcker木马作为默认的端口。

操作建议：建议关闭该端口。

80端口：80端口是为HTTP（HyperText Transport Protocol，超文本传输协议）开放的，这是上网冲浪使用最多的协议，主要用于在WWW（World Wide Web，万维网）服务上传输信息的协议。

端口说明：80端口是为HTTP（HyperText Transport Protocol，超文本传输协议）开放的，这是上网冲浪使用最多的协议，主要用于在WWW（World Wide Web，万维网）服务上传输信息的协议。我们可以通过HTTP地址加“:80”（即常说的“网址”）来访问网站的，比如http://www.cce.com.cn:80，因为浏览网页服务默认的端口号是80，所以只要输入网址，不用输入“:80”。

端口漏洞：有些木马程序可以利用80端口来攻击计算机的，比如Executor、RingZero等。

操作建议：为了能正常上网冲浪，我们必须开启80端口。

99端口：99端口是用于一个名为“Metagram Relay”（亚对策延时）的服务，该服务比较少见，一般是用不到的。

端口说明：99端口是用于一个名为“Metagram Relay”（亚对策延时）的服务，该服务比较少见，一般是用不到的。

端口漏洞：虽然“Metagram Relay”服务不常用，可是Hidden Port、NCx99等木马程序会利用该端口，比如在Windows 2000中，NCx99可以把cmd．exe程序绑定到99端口，这样用Telnet就可以连接到服务器，随意添加用户、更改权限。

操作建议：建议关闭该端口。

109、110端口：109端口是为POP2（Post Office Protocol Version 2，邮局协议2）服务开放的，110端口是为POP3（邮件协议3）服务开放的，POP2、POP3都是主要用于接收邮件的。

端口说明：109端口是为POP2（Post Office Protocol Version 2，邮局协议2）服务开放的，110端口是为POP3（邮件协议3）服务开放的，POP2、POP3都是主要用于接收邮件的，目前POP3使用的比较多，许多服务器都同时支持POP2和POP3。客户端可以使用POP3协议来访问服务端的邮件服务，如今ISP的绝大多数邮件服务器都是使用该协议。在使用电子邮件客户端程序的时候，会要求输入POP3服务器地址，默认情况下使用的就是110端口。

端口漏洞：POP2、POP3在提供邮件接收服务的同时，也出现了不少的漏洞。单单POP3服务在用户名和密码交换缓冲区溢出的漏洞就不少于20个，比如WebEasyMail POP3 Server合法用户名信息泄露漏洞，通过该漏洞远程攻击者可以验证用户账户的存在。另外，110端口也被ProMail trojan等木马程序所利用，通过110端口可以窃取POP账号用户名和密码。

操作建议：如果是执行邮件服务器，可以打开该端口。

111端口：111端口是SUN公司的RPC（Remote Procedure Call，远程过程调用）服务所开放的端口，主要用于分布式系统中不同计算机的内部进程通信，RPC在多种网络服务中都是很重要的组件。

端口说明：111端口是SUN公司的RPC（Remote Procedure Call，远程过程调用）服务所开放的端口，主要用于分布式系统中不同计算机的内部进程通信，RPC在多种网络服务中都是很重要的组件。常见的RPC服务有rpc．mountd、NFS、rpc．statd、rpc．csmd、rpc．ttybd、amd等等。在Microsoft的Windows中，同样也有RPC服务。

端口漏洞：SUN RPC有一个比较大漏洞，就是在多个RPC服务时xdr＿array函数存在远程缓冲溢出漏洞，通过该漏洞允许攻击者传递超

113端口：113端口主要用于Windows的“Authentication Service”（验证服务）。

端口说明：113端口主要用于Windows的“Authentication Service”（验证服务），一般与网络连接的计算机都运行该服务，主要用于验证TCP连接的用户，通过该服务可以获得连接计算机的信息。在Windows 2000/2003 Server中，还有专门的IAS组件，通过该组件可以方便远程访问中进行身份验证以及策略管理。

端口漏洞：113端口虽然可以方便身份验证，但是也常常被作为FTP、POP、SMTP、IMAP以及IRC等网络服务的记录器，这样会被相应的木马程序所利用，比如基于IRC聊天室控制的木马。另外，113端口还是Invisible Identd Deamon、Kazimas等木马默认开放的端口。

操作建议：建议关闭该端口。

119端口：119端口是为“Network News Transfer Protocol”（网络新闻组传输协议，简称NNTP）开放的。

端口说明：119端口是为“Network News Transfer Protocol”（网络新闻组传输协议，简称NNTP）开放的，主要用于新闻组的传输，当查找USENET服务器的时候会使用该端口。

端口漏洞：著名的Happy99蠕虫病毒默认开放的就是119端口，如果中了该病毒会不断发送电子邮件进行传播，并造成网络的堵塞。

操作建议：如果是经常使用USENET新闻组，就要注意不定期关闭该端口。

135端口：135端口主要用于使用RPC（Remote Procedure Call，远程过程调用）协议并提供DCOM（分布式组件对象模型）服务。

端口说明：135端口主要用于使用RPC（Remote Procedure Call，远程过程调用）协议并提供DCOM（分布式组件对象模型）服务，通过RPC可以保证在一台计算机上运行的程序可以顺利地执行远程计算机上的代码；使用DCOM可以通过网络直接进行通信，能够跨包括HTTP协议在内的多种网络传输。

端口漏洞：相信去年很多Windows 2000和Windows XP用户都中了“冲击波”病毒，该病毒就是利用RPC漏洞来攻击计算机的。RPC本身在处理通过TCP/IP的消息交换部分有一个漏洞，该漏洞是由于错误地处理格式不正确的消息造成的。该漏洞会影响到RPC与DCOM之间的一个接口，该接口侦听的端口就是135。

操作建议：为了避免“冲击波”病毒的攻击，建议关闭该端口。

137端口：137端口主要用于“NetBIOS Name Service”（NetBIOS名称服务）。

端口说明：137端口主要用于“NetBIOS Name Service”（NetBIOS名称服务），属于UDP端口，使用者只需要向局域网或互联网上的某台计算机的137端口发送一个请求，就可以获取该计算机的名称、注册用户名，以及是否安装主域控制器、IIS是否正在运行等信息。

端口漏洞：因为是UDP端口，对于攻击者来说，通过发送请求很容易就获取目标计算机的相关信息，有些信息是直接可以被利用，并分析漏洞的，比如IIS服务。另外，通过捕获正在利用137端口进行通信的信息包，还可能得到目标计算机的启动和关闭的时间，这样就可以利用专门的工具来攻击。

操作建议：建议关闭该端口。

139端口：139端口是为“NetBIOS Session Service”提供的，主要用于提供Windows文件和打印机共享以及Unix中的Samba服务。

端口说明：139端口是为“NetBIOS Session Service”提供的，主要用于提供Windows文件和打印机共享以及Unix中的Samba服务。在Windows中要在局域网中进行文件的共享，必须使用该服务。比如在Windows 98中，可以打开“控制面板”，双击“网络”图标，在“配置”选项卡中单击“文件及打印共享”按钮选中相应的设置就可以安装启用该服务；在Windows 2000/XP中，可以打开“控制面板”，双击“网络连接”图标，打开本地连接属性；接着，在属性窗口的“常规”选项卡中选择“Internet协议（TCP/IP）”，单击“属性”按钮；然后在打开的窗口中，单击“高级”按钮；在“高级TCP/IP设置”窗口中选择“WINS”选项卡，在“NetBIOS设置”区域中启用TCP/IP上的NetBIOS。

端口漏洞：开启139端口虽然可以提供共享服务，但是常常被攻击者所利用进行攻击，比如使用流光、SuperScan等端口扫描工具，可以扫描目标计算机的139端口，如果发现有漏洞，可以试图获取用户名和密码，这是非常危险的。

操作建议：如果不需要提供文件和打印机共享，建议关闭该端口。

143端口：143端口主要是用于“Internet Message Access Protocol”v2（Internet消息访问协议，简称IMAP）。

端口说明：143端口主要是用于“Internet Message Access Protocol”v2（Internet消息访问协议，简称IMAP），和POP3一样，是用于电子邮件的接收的协议。通过IMAP协议我们可以在不接收邮件的情况下，知道信件的内容，方便管理服务器中的电子邮件。不过，相对于POP3协议要负责一些。如今，大部分主流的电子邮件客户端软件都支持该协议。

端口漏洞：同POP3协议的110端口一样，IMAP使用的143端口也存在缓冲区溢出漏洞，通过该漏洞可以获取用户名和密码。另外，还有一种名为“admv0rm”的Linux蠕虫病毒会利用该端口进行繁殖。

操作建议：如果不是使用IMAP服务器操作，应该将该端口关闭。

161端口：161端口是用于“Simple Network Management Protocol”（简单网络管理协议，简称SNMP）。

端口说明：161端口是用于“Simple Network Management Protocol”（简单网络管理协议，简称SNMP），该协议主要用于管理TCP/IP网络中的网络协议，在Windows中通过SNMP服务可以提供关于TCP/IP网络上主机以及各种网络设备的状态信息。目前，几乎所有的网络设备厂商都实现对SNMP的支持。

在Windows 2000/XP中要安装SNMP服务，我们首先可以打开“Windows组件向导”，在“组件”中选择“管理和监视工具”，单击“详细信息”按钮就可以看到“简单网络管理协议（SNMP）”，选中该组件；然后，单击“下一步”就可以进行安装。

端口漏洞：因为通过SNMP可以获得网络中各种设备的状态信息，还能用于对网络设备的控制，所以黑客可以通过SNMP漏洞来完全控制网络。

操作建议：建议关闭该端口。

443端口：443端口即网页浏览端口，主要是用于HTTPS服务，是提供加密和通过安全端口传输的另一种HTTP。

端口说明：443端口即网页浏览端口，主要是用于HTTPS服务，是提供加密和通过安全端口传输的另一种HTTP。在一些对安全性要求较高的网站，比如银行、证券、购物等，都采用HTTPS服务，这样在这些网站上的交换信息其他人都无法看到，保证了交易的安全性。网页的地址以https://开始，而不是常见的http://。

端口漏洞：HTTPS服务一般是通过SSL（安全套接字层）来保证安全性的，但是SSL漏洞可能会受到黑客的攻击，比如可以黑掉在线银行系统，盗取信用卡账号等。

操作建议：建议开启该端口，用于安全性网页的访问。另外，为了防止黑客的攻击，应该及时安装微软针对SSL漏洞发布的最新安全补丁。

554端口：554端口默认情况下用于“Real Time Streaming Protocol”（实时流协议，简称RTSP）。

端口说明：554端口默认情况下用于“Real Time Streaming Protocol”（实时流协议，简称RTSP），该协议是由RealNetworks和Netscape共同提出的，通过RTSP协议可以借助于Internet将流媒体文件传送到RealPlayer中播放，并能有效地、最大限度地利用有限的网络带宽，传输的流媒体文件一般是Real服务器发布的，包括有.rm、.ram。如今，很多的下载软件都支持RTSP协议，比如FlashGet、影音传送带等等。

端口漏洞：目前，RTSP协议所发现的漏洞主要就是RealNetworks早期发布的Helix Universal Server存在缓冲区溢出漏洞，相对来说，使用的554端口是安全的。

操作建议：为了能欣赏并下载到RTSP协议的流媒体文件，建议开启554端口。

1024端口：1024端口一般不固定分配给某个服务，在英文中的解释是“Reserved”（保留）。

端口说明：1024端口一般不固定分配给某个服务，在英文中的解释是“Reserved”（保留）。之前，我们曾经提到过动态端口的范围是从1024～65535，而1024正是动态端口的开始。该端口一般分配给第一个向系统发出申请的服务，在关闭服务的时候，就会释放1024端口，等待其他服务的调用。

端口漏洞：著名的YAI木马病毒默认使用的就是1024端口，通过该木马可以远程控制目标计算机，获取计算机的屏幕图像、记录键盘事件、获取密码等，后果是比较严重的。

操作建议：一般的杀毒软件都可以方便地进行YAI病毒的查杀，所以在确认无YAI病毒的情况下建议开启该端口。

posted @ 2011-11-01 11:12 abin 阅读(320) | 评论 (0) | 编辑收藏

servlet 下载文件

摘要: <servlet> <description>This is the description of my J2EE component</description> <display-name>This is the display name of my J2EE comp... 阅读全文

posted @ 2011-10-31 20:15 abin 阅读(1162) | 评论 (0) | 编辑收藏

springMVC入门

作为一个J2EE的开发者，我们基本上是开发基于WEB的应用系统。事实上，工作流，状态管理以及验证都是需要解决的重要功能。而HTTP协议的无状态性决定了这些功能都不容易实现。Spring的WEB框架就是来帮助我们解决这些问题的。使用Spring，我们可以让WEB框架自动将传递进来的请求参数填充到模型对象中，同时提供验证和错误处理。还可以管理用户在WEB表单中创建的对象的状态。在了解SpringMVC之前，我们先来复习下MVC.

MVC从逻辑上把应用分为模型组件，视图组件和控制器组件。其中控制器组件又可以细分为：前端控制器组件和后端控制器组件。

我们来看一下MVC的基本工作流程：

首先是客户端（通常是浏览器）发出一个请求。第一个接受这个请求的组件一般是一个前端控制器。它将不同的请求交给不同的后端控制器来处理，而在后端控制器里面又可以调用相应的模型对象来处理具体的业务逻辑，最后再返回一个特定的视图响应给客户端。

怎么理解MVC呢？我们举一个现实的例子，前段时间地震太可怕了，全国人民都在上下一心抗震救灾。我们敬爱的温总理给武警司令下命令让他完成抗震救灾的艰巨任务，于是武警司令就根据各地情况派遣不同类型的特种兵到不同的地区去，然后特种兵使用大大小小的工具完成了任务，最后上交给司令一份统计图表，司令再上交给温总理。我们就来分析一下，这符不符合MVC的设计模式。这里呢，温总理就是客户端，武警司令就是前端控制器，特种兵就是后端控制器，特种兵所使用的工具就是模型，最后上交的统计图表就是视图。

现在大家应该可以理解MVC的设计思想了。拿我们比较熟悉的struts框架来说，前端控制器就是ActionServlet,后端控制器就是Action.请求的URL和后端控制器的映射关系在struts-config.xml上的<action-mappings>里面配置，模型对象就是我们平常写的DAO/DTO，返回的视图类型一般就是jsp了。

那么，在spring MVC中又是怎样的呢?，我们先按上面对号入座地说一下。第一个接受这个请求的前端控制器叫DispatcherServlet，后端控制器叫Controller。负责处理请求URL和后端控制器映射的叫HandMapping，它有多种类型，比较灵活，也是在一个xml文件上进行配置。负责业务逻辑处理的模型对象一般也是我们平常写的DAO/DTO组件。只是它最后的返回更灵活，Controller返回一个ModelAndView对象给DispatcherServlet，ModelAndView可以携带一个视图对象，也可以携带一个视图对象的逻辑名。如果携带的是一个视图对象的逻辑名，那DispatcherServlet需要一个ViewResolver来查找用于渲染回应的视图对象。最后，DispatcherServlet将请求分派给ModelAndView对象指定的视图对象。视图对象负责渲染返回给客户的回应。

我们学习知识，一样要注意运用类比迁移的方法。有人说，我学会了struts，但学不会springMVC。这是说不过去的。因为二者的思想完全一致。所以，我们只需要学习它们不一样的地方就可以啦。好，我们现在先跑一个最简单的例子，让大家对构建SpringMVC的基本步骤有个直观的认识。大家要边跑边跟struts做比较。

(1)建立动态web工程，导入spring的jar包。

(2)配置DispatcherServlet

DispatcherServlet是SpringMVC的核心，将下面Servlet的注册信息登记在web.xml中。一定要记住：Servlet跟伴侣一样，要结婚，先得注册登记！

<servlet-name>test</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>test</servlet-name>

<url-pattern>*.do</url-pattern>

</servlet-mapping>

(3)编写Controller，做核心配置文件，并配置url和Controller的映射

package com.wepull.test;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;

import org.springframework.web.servlet.mvc.Controller;

public classHelloController implements Controller{

public ModelAndView handleRequest(HttpServletRequest request,

HttpServletResponse response) throws Exception {

request.setAttribute("hello", "welcome to spring!");

return new ModelAndView("welcome");

}

我们知道Struts有个XML格式的核心配置文件，springMVC当然也有，在WEB-INF下新建一XML文件:test-servlet.xml.注意，这里的test取决于servlet的名字.当DispatcherServlet载入后，它将试图从这个文件中载入应用上下文。

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

<bean id="beanNameUrlMapping"

class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">

</bean>

<bean name="/hello.do"

class="com.wepull.test.HelloController">

</bean>

</beans>

上面可能有人奇怪，为什么不用id属性，而设置name属性。这里是因为URL中含有XML id属性非法字符——特别是斜杠（/）;

(4)配置一个视图解析器将控制器与JSP结合起来。

将解析器的配置片段加到上面的test-servlet.xml中。

<bean id="viewResolver"

class="org.springframework.web.servlet.view.InternalResourceViewResolver">

</bean>

InternalResourceViewResolver在ModelAndView返回的视图名前加上prefix属性配置的前缀,再在最后加上suffix属性配置的后缀。由于HelloController返回的ModelAndView中视图名为welcome,所以InternalResourceViewResolver将在/WEB-INF/jsp/welcome.jsp处查找视图。

(5)编写呈现给用户的jsp文件。

/WEB-INF/jsp/welcome.jsp

<%@ page contentType="text/html; charset=UTF-8"%>

<%@ page isELIgnored="false" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<head>

<title>Hello World!</title>

</head>

<body>

<h2>

${hello}

</h2>

</body>

</html>

完成后启动服务器，在浏览器地址栏上输入http://locahost:8080/projectName/hello.do 就可以访问了。

对照一下，我们发现SpringMVC跟Struts大同小异。只是有两处映射，SpringMVC做的相对灵活。哪两处呢？

(1) url和动作(后端控制器)的映射。

springMVC里有个映射处理器(HandlerMapping)的概念。它实际上是一个处理器映射Bean,用来将一个控制器指定到一个URL上。Spring提供了三种有用的HandlerMapping的实现：

——BeanNameUrlHandlerMapping

根据控制器的名字将控制器映射到URL

——SimpleUrlHandlerMapping

用上下文配置文件中定义的属性集合将控制器映射到URL

——CommonsPathMapHandlerMapping

使用控制器代码中的元数据将控制器映射到URL

(2) 逻辑视图名和视图对象的映射。

springMVC里还有个视图解析器(ViewResolver)的概念。它决定了ModelAndView对象的逻辑视图名如何解析成一个用于将结果渲染给用户的视图Bean..Spring有四种ViewResolver实现：

——InternalResourceViewResolver

将逻辑视图名解析成一个用模板文件(如JSP和Velocity模板)渲染的视图对象

——BeanNameViewResolver

将逻辑视图名解析成一个DispatcherServlet应用上下文中的视图Bean

——ResourceBundleViewResolver

将逻辑视图名解析成一个ResourceBundler中的视图对象

—— XmlViewResolver

从一个XML文件中解析视图Bean,这个文件是从DispatcherServlet应用上下文中分离出来的。

好啦，今天就算是SpringMVC的一个入门。建议大家将Struts和SpringMVC对照着学习，那样效果会更好。与人分享，集思广益。希望大家都能够学习快乐，工作顺心。下次再见。

出处：http://blog.csdn.net/lenotang/article/details/2562348

posted @ 2011-10-23 22:08 abin 阅读(1043) | 评论 (1) | 编辑收藏

Java 接收邮件(接收多附件)

//Java接收邮件主程序：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Properties;

import javax.mail.BodyPart;
import javax.mail.Flags;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.Part;
import javax.mail.Session;
import javax.mail.Store;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeUtility;

/**
* @author Administrator
*
*/
public class PraseMimeMessage {
   private MimeMessage mimeMessage = null;

   private String saveAttachPath = "d:\\";// 附件下载后的存放目录

   private StringBuffer bodytext = new StringBuffer();

   // 存放邮件内容的StringBuffer对象
   private String dateformat = "yy-MM-dd　HH:mm";// 默认的日前显示格式

   /**
   * 构造函数,初始化一个MimeMessage对象
   */
   public PraseMimeMessage() {
   }

   public PraseMimeMessage(MimeMessage mimeMessage) {
       this.mimeMessage = mimeMessage;
//       System.out.println("create　a　PraseMimeMessage　object........");
   }

   public void setMimeMessage(MimeMessage mimeMessage) {
       this.mimeMessage = mimeMessage;
   }

   /**
   *
   * 获取发件人的姓名和密码
   *
   * @return
   */
   public String getFrom() throws Exception {
       InternetAddress address[] = (InternetAddress[]) mimeMessage.getFrom();
       String from = address[0].getAddress();
       if (from == null)
           from = "";
       String personal = address[0].getPersonal();
       if (personal == null)
           personal = "";
       String fromaddr = personal + "<" + from + ">";
       return fromaddr;
   }

   /**
   * 获得邮件的收件人，抄送，和密送的地址和姓名，根据所传递的参数的不同 "to"----收件人 "cc"---抄送人地址 "bcc"---密送人地址
   */

   public String getMailAddress(String type) throws Exception {
       String mailaddr = "";
       String addtype = type.toUpperCase();
       InternetAddress[] address = null;
       if (addtype.equals("TO") || addtype.equals("CC")
               || addtype.equals("BCC"))

       {
           if (addtype.equals("TO")) {
               address = (InternetAddress[]) mimeMessage
                       .getRecipients(Message.RecipientType.TO);
           } else if (addtype.equals("CC")) {
               address = (InternetAddress[]) mimeMessage
                       .getRecipients(Message.RecipientType.CC);
           } else {
               address = (InternetAddress[]) mimeMessage
                       .getRecipients(Message.RecipientType.BCC);
           }
           if (address != null) {
               for (int i = 0; i < address.length; i++) {
                   String email = address[i].getAddress();
                   if (email == null)
                       email = "";
                   else {
                       email = MimeUtility.decodeText(email);
                   }
                   String personal = address[i].getPersonal();
                   if (personal == null)
                       personal = "";
                   else {
                       personal = MimeUtility.decodeText(personal);
                   }
                   String compositeto = personal + "<" + email + ">";
                   mailaddr += "," + compositeto;
               }
               mailaddr = mailaddr.substring(1);
           }
       } else {
           throw new Exception("Error　emailaddr　type!");
       }
       return mailaddr;
   }

   /**
   *
   * 获取邮件主题
   */
   public String getSubject() throws MessagingException {
       String subject = "";
       try {
           subject = MimeUtility.decodeText(mimeMessage.getSubject());
           if (subject == null)
               subject = "";
       } catch (Exception exce) {
       }
       return subject;
   }

   /*
   * 获取邮件发送日期
   *
   */

   public java.util.Date getSentDate() throws Exception {
       Date sentdate = mimeMessage.getSentDate();
       SimpleDateFormat format = new SimpleDateFormat(dateformat);
       return sentdate;
   }

   /**
   * 获取邮件正文
   *
   * @return
   *
   */

   public String getBodyText() {
       return bodytext.toString();
   }

   /**
   * 解析邮件，把得到的邮件内容保存到一个StringBuffer对象中，解析邮件主要是根据MimeType类型的不同执行不同的操作，一步一步的解析
   *
   *
   */

   public void getMailContent(Part part) throws Exception {
       String contenttype = part.getContentType();
       int nameindex = contenttype.indexOf("name");
       boolean conname = false;
       if (nameindex != -1)
           conname = true;
//       System.out.println("CONTENTTYPE:　" + contenttype);
       if (part.isMimeType("text/plain") && !conname) {
           bodytext.append((String) part.getContent());
       } else if (part.isMimeType("text/html") && !conname) {
           bodytext.append((String) part.getContent());
       } else if (part.isMimeType("multipart/*")) {
           Multipart multipart = (Multipart) part.getContent();
           int counts = multipart.getCount();
           for (int i = 0; i < counts; i++) {
               getMailContent(multipart.getBodyPart(i));
           }
       } else if (part.isMimeType("message/rfc822")) {
           getMailContent((Part) part.getContent());
       } else {
       }
   }

   /**
   *
   * 判断此邮件是否需要回执，如果需要回执返回"true",否则返回"false"
   *
   */

   public boolean getReplySign() throws MessagingException {
       boolean replysign = false;
       String needreply[] = mimeMessage
               .getHeader("Disposition-Notification-To");
       if (needreply != null) {
           replysign = true;
       }
       return replysign;
   }

   /*
   * 获得此邮件的Message-ID
   *
   */

   public String getMessageId() throws MessagingException {
       return mimeMessage.getMessageID();
   }

   /*
   * 【判断此邮件是否已读，如果未读返回返回false,反之返回true】
   *
   */

   public boolean isNew() throws MessagingException {
       boolean isnew = false;
       Flags flags = ((Message) mimeMessage).getFlags();
       Flags.Flag[] flag = flags.getSystemFlags();
//       System.out.println("flags's　length:　" + flag.length);
       for (int i = 0; i < flag.length; i++) {
           if (flag[i] == Flags.Flag.SEEN) {
               isnew = true;
//               System.out.println("seen　Message.......");
               break;
           }
       }
       return isnew;
   }

   /**
   *
   * 判断此邮件是否包含附件
   *
   */

   public boolean isContainAttach(Part part) throws Exception {
       boolean attachflag = false;
       String contentType = part.getContentType();
       if (part.isMimeType("multipart/*")) {
           Multipart mp = (Multipart) part.getContent();
           for (int i = 0; i < mp.getCount(); i++) {
               BodyPart mpart = mp.getBodyPart(i);
               String disposition = mpart.getDisposition();
               if ((disposition != null)
                       && ((disposition.equals(Part.ATTACHMENT)) || (disposition
                               .equals(Part.INLINE))))
                   attachflag = true;
               else if (mpart.isMimeType("multipart/*")) {
                   attachflag = isContainAttach((Part) mpart);
               } else {
                   String contype = mpart.getContentType();
                   if (contype.toLowerCase().indexOf("application") != -1)
                       attachflag = true;
                   if (contype.toLowerCase().indexOf("name") != -1)
                       attachflag = true;
               }
           }
       } else if (part.isMimeType("message/rfc822")) {
           attachflag = isContainAttach((Part) part.getContent());
       }
       return attachflag;
   }
    //base64解码
    private static String base64Decoder(String s) throws Exception {
        sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
        byte[] b = decoder.decodeBuffer(s);
        return (new String(b));
    }

   /*
   * 保存附件
   *
   */
   public String saveAttachMent(Part part) throws Exception {
       String fileName = "";
       StringBuffer stb=new StringBuffer();
       if (part.isMimeType("multipart/*")) {
           Multipart mp = (Multipart) part.getContent();
           for (int i = 0; i < mp.getCount(); i++) {
               BodyPart mpart = mp.getBodyPart(i);
               String disposition = mpart.getDisposition();
               if ((disposition != null)
                       && ((disposition.equals(Part.ATTACHMENT)) || (disposition
                               .equals(Part.INLINE)))) {
                   fileName = mpart.getFileName();
                   /*System.out.println(fileName);
                   fileName=fileName.substring(fileName.indexOf("=?GBK?B?"));
                   System.out.println(fileName);
                   fileName=fileName.substring(0, fileName.length()-2);
                   System.out.println(fileName);*/
//                   .substring(fileName.lastIndexOf("=?GBK?B?"), fileName.indexOf("?="));
                     String s = fileName.substring(8, fileName.indexOf("?="));;
                     fileName = base64Decoder(s);
                     stb.append(fileName);
                       stb.append(",");
                   if (fileName.toLowerCase().indexOf("gb2312") != -1) {
                       fileName = MimeUtility.decodeText(fileName);
                       stb.append(fileName);
                       stb.append(",");
                   }
                   // saveFile(fileName,mpart.getInputStream());
                   saveFile(fileName, mpart.getInputStream());

               } else if (mpart.isMimeType("multipart/*")) {
                   saveAttachMent(mpart);
               } else {
                   fileName = mpart.getFileName();
                   if ((fileName != null)
                           && (fileName.toLowerCase().indexOf("GB2312") != -1)) {
                       fileName = MimeUtility.decodeText(fileName);
                       stb.append(fileName);
                       stb.append(",");

                       saveFile(fileName, mpart.getInputStream());
                   }
               }
           }
       } else if (part.isMimeType("message/rfc822")) {
           saveAttachMent((Part) part.getContent());
       }
       return stb.toString();
   }

   /**
   * 【设置附件存放路径】
   */

   public void setAttachPath(String attachpath) {
       this.saveAttachPath = attachpath;
   }

   /**
   *
   * 设置日期显示本格式
   */
   public void setDateFormat(String format) throws Exception {
       this.dateformat = format;
   }

   /**
   * 【获得附件存放路径】
   */

   public String getAttachPath() {
       return saveAttachPath;
   }

   /**
   * 【真正的保存附件到指定目录里】
   */

   private void saveFile(String fileName, InputStream in) throws Exception {

       String osName = System.getProperty("os.name");
       String storedir = getAttachPath();
       String separator = "";
       if (osName == null)
           osName = "";
       if (osName.toLowerCase().indexOf("win") != -1) {
           separator = "\\";
           if (storedir == null || storedir.equals(""))
               storedir = "c:\\tmp";
       } else {
           separator = "/";
           storedir = "/tmp";
       }
       File storefile = new File(storedir + separator + fileName);
//       System.out.println("storefile's　path:　" + storefile.toString());

       BufferedOutputStream bos = null;
       BufferedInputStream bis = null;
       try {
           bos = new BufferedOutputStream(new FileOutputStream(storefile));
           bis = new BufferedInputStream(in);
           int c;
           while ((c = bis.read()) != -1) {
               bos.write(c);
               bos.flush();
           }
       } catch (Exception exception) {
           exception.printStackTrace();
           throw new Exception("文件保存失败!");
       } finally {
           bos.close();
           bis.close();
       }
   }

   /**
   * PraseMimeMessage类测试
   */

   public static void main(String args[]) throws Exception {
       String host = "POP3.163.com";// 【POP3.163.com】
       String username = "liposter";// 【yuxia2217】
       String password = "liisposter";// 【........】
       Properties props = new Properties();
       Session session = Session.getDefaultInstance(props, null);
       Store store = session.getStore("pop3");
       store.connect(host, username, password);
       Folder folder = store.getFolder("INBOX");
       folder.open(Folder.READ_ONLY);
       Message message[] = folder.getMessages();
       System.out.println("Messages's　length:　" + message.length);
       PraseMimeMessage pmm = null;
       for (int i = 0; i < message.length; i++) {
           pmm = new PraseMimeMessage((MimeMessage) message[i]);
           System.out
                   .println("Message　" + i + "　subject:　" + pmm.getSubject());
           System.out.println("Message　" + i + "　sentdate:　"
                   + pmm.getSentDate());
           System.out.println("Message　" + i + "　replysign:　"
                   + pmm.getReplySign());
           System.out.println("Message　新的" + i + "　hasRead:　" + pmm.isNew());
           System.out.println("Message　附件" + i + "　　containAttachment:　"
                   + pmm.isContainAttach((Part) message[i]));
           System.out.println("Message　" + i + "　form:　" + pmm.getFrom());
           System.out.println("Message　" + i + "　to:　"
                   + pmm.getMailAddress("to"));
           System.out.println("Message　" + i + "　cc:　"
                   + pmm.getMailAddress("cc"));
           System.out.println("Message　" + i + "　bcc:　"
                   + pmm.getMailAddress("bcc"));
           pmm.setDateFormat("yy年MM月dd日　HH:mm");
           System.out.println("Message" + i + "　sentdate:　"
                   + pmm.getSentDate());
           System.out.println("Message　" + i + "　Message-ID:　"
                   + pmm.getMessageId());
           pmm.getMailContent((Part) message[i]);
           System.out.println("Message　正文" + i + "　bodycontent:　\r\n"
                   + pmm.getBodyText());
           pmm.setAttachPath("D:\\image");
           pmm.saveAttachMent((Part) message[i]);


       }
   }
   public List<MailInfo> receive(MailInfo mailInfo)throws Exception{
       List<MailInfo> list=new ArrayList<MailInfo>();
       Properties props = new Properties();
       Session session = Session.getDefaultInstance(props, null);
       Store store = session.getStore("pop3");
       store.connect(mailInfo.getHost(), mailInfo.getUsername(), mailInfo.getPassword());
       Folder folder = store.getFolder("INBOX");
       folder.open(Folder.READ_ONLY);
       Message message[] = folder.getMessages();
   //   System.out.println("Messages's　length:　" + message.length);
       PraseMimeMessage pmm = null;
       for (int i = 0; i < message.length; i++) {
           MailInfo mail=new MailInfo();
           mail.setMailnumber(message.length);
           pmm = new PraseMimeMessage((MimeMessage) message[i]);
//           System.out
//                   .println("Message　" + i + "　subject:　" + pmm.getSubject());
           mail.setSubject(message[i].getSubject());
//           System.out.println("Message　" + i + "　sentdate:　"
//                   + pmm.getSentDate());
           mail.setSentdate(pmm.getSentDate());
//           System.out.println("Message　" + i + "　replysign:　"
//                   + pmm.getReplySign());
           mail.setReplysign(pmm.getReplySign());
//           System.out.println("Message　新的" + i + "　hasRead:　" + pmm.isNew());
//           mail.setRead(pmm.isNew());
//           System.out.println("Message　附件" + i + "　　containAttachment:　"
//                   + pmm.isContainAttach((Part) message[i]));
           mail.setExistsFile(pmm.isContainAttach((Part) message[i]));
//           System.out.println("Message　" + i + "　form:　" + pmm.getFrom());
           mail.setFromAddress(pmm.getFrom().substring(1, pmm.getFrom().length()).replaceAll(">", ""));
//           System.out.println("Message　" + i + "　to:　"
//                   + pmm.getMailAddress("to"));
           mail.setToAddress(pmm.getMailAddress("to").substring(1, pmm.getMailAddress("to").length()).replaceAll(">", ""));
//           System.out.println("Message　" + i + "　cc:　"
//                   + pmm.getMailAddress("cc"));
//           mail.setMailauthor(pmm.getMailAddress("cc"));
//           System.out.println("Message　" + i + "　bcc:　"
//                   + pmm.getMailAddress("bcc"));
           pmm.setDateFormat("yy年MM月dd日　HH:mm");
//           System.out.println("Message" + i + "　sentdate:　"
//                   + pmm.getSentDate());
//           System.out.println("Message　" + i + "　Message-ID:　"
//                   + pmm.getMessageId());
           mail.setMessageid(pmm.getMessageId());
           pmm.getMailContent((Part) message[i]);
//           System.out.println("Message　正文" + i + "　bodycontent:　\r\n"
//                   + pmm.getBodyText());
           mail.setContent(pmm.getBodyText());
           pmm.setAttachPath(mailInfo.getFilepath()[0]);
           String fileName=pmm.saveAttachMent((Part) message[i]);
           String[] file=new String[]{};
           file=fileName.split(",");
           String[] receivepath=new String[3];
           for(int j=0;j<file.length;j++){
               receivepath[j]=mailInfo.getFilepath()[0]+"\\"+file[j];
           }
           mail.setReceivepath(receivepath);
           list.add(mail);
   }
       return list;
}
}

//实体类

/**
* 发送邮件的基本信息
* @author dell
*
*/
public class MailInfo implements java.io.Serializable{

   private String host;//发送邮件的主机号
   private String port;//发送邮件的端口号
   private String fromAddress;//发送邮件地址
   private String toAddress;//接收邮件地址
   private String username;//发送邮件用户的用户名
   private String password;//发送邮件用户的密码
   private String validate;//是否需要身份的验证:ture认证，false不认证信息
   private String subject;//邮件主题
   private String content;//邮件的内容,分为文本，超文本，html等形式
   private String[] filepath;//发送邮件的附件的位置
   private String[] sendAddress;//接收邮件地址
   private String filename;//发送邮件的附件显示的名称
   private String[] receivepath;//接收邮件的时候附件保存的路径
   private java.util.Date sentdate;
   private float filesize;
   private java.util.Date receivedate;
   private String mailauthor;//邮件作者
   private boolean read;//是否读过，true读过，false没有阅读过
   private boolean ExistsFile;//是否有附件true有，false没有
   private boolean replysign;//是否有回执
   private String messageid;//消息ID
   private int mailnumber;//邮件数目，一个用户的总邮件数


   public String[] getSendAddress() {
       return sendAddress;
   }
   public void setSendAddress(String[] sendAddress) {
       this.sendAddress = sendAddress;
   }
   public int getMailnumber() {
       return mailnumber;
   }
   public void setMailnumber(int mailnumber) {
       this.mailnumber = mailnumber;
   }
   public String getMessageid() {
       return messageid;
   }
   public void setMessageid(String messageid) {
       this.messageid = messageid;
   }
   public boolean isExistsFile() {
       return ExistsFile;
   }
   public boolean isRead() {
       return read;
   }
   public void setExistsFile(boolean existsFile) {
       ExistsFile = existsFile;
   }
   public void setRead(boolean read) {
       this.read = read;
   }
   public boolean isReplysign() {
       return replysign;
   }
   public void setReplysign(boolean replysign) {
       this.replysign = replysign;
   }
   public String getMailauthor() {
       return mailauthor;
   }
   public void setMailauthor(String mailauthor) {
       this.mailauthor = mailauthor;
   }
   public java.util.Date getReceivedate() {
       return receivedate;
   }
   public void setReceivedate(java.util.Date receivedate) {
       this.receivedate = receivedate;
   }

   public java.util.Date getSentdate() {
       return sentdate;
   }
   public void setSentdate(java.util.Date sentdate) {
       this.sentdate = sentdate;
   }

   public String[] getFilepath() {
       return filepath;
   }
   public void setFilepath(String[] filepath) {
       this.filepath = filepath;
   }
   public String getContent() {
       return content;
   }
   public String getFilename() {
       return filename;
   }
   public String getFromAddress() {
       return fromAddress;
   }
   public String getHost() {
       return host;
   }
   public String getPassword() {
       return password;
   }
   public String getPort() {
       return port;
   }
   public String getSubject() {
       return subject;
   }
   public String getToAddress() {
       return toAddress;
   }
   public String getUsername() {
       return username;
   }
   public void setContent(String content) {
       this.content = content;
   }
   public void setFilename(String filename) {
       this.filename = filename;
   }
   public void setFromAddress(String fromAddress) {
       this.fromAddress = fromAddress;
   }
   public void setHost(String host) {
       this.host = host;
   }
   public void setPassword(String password) {
       this.password = password;
   }
   public void setPort(String port) {
       this.port = port;
   }
   public void setSubject(String subject) {
       this.subject = subject;
   }
   public void setToAddress(String toAddress) {
       this.toAddress = toAddress;
   }
   public void setUsername(String username) {
       this.username = username;
   }
   public String getValidate() {
       return validate;
   }
   public void setValidate(String validate) {
       this.validate = validate;
   }
   public String[] getReceivepath() {
       return receivepath;
   }
   public void setReceivepath(String[] receivepath) {
       this.receivepath = receivepath;
   }





}

//测试代码：

import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class ReceiveTest{
   @Before
   public void setUp() throws Exception {
   }

   @After
   public void tearDown() throws Exception {
   }
   @Test
   public void ReceiveMailTest()throws Exception{
       MailInfo mailInfo=new MailInfo();
       mailInfo.setHost("pop.163.com");
       mailInfo.setUsername("liposter");
       mailInfo.setPassword("********");
       String[] fdess=new String[]{"D:\\image"};
       mailInfo.setFilepath(fdess);
       List<MailInfo> list=new PraseMimeMessage().receive(mailInfo);
       for(int i=0;i<list.size();i++){
           System.out.println("Mailnumber="+list.get(i).getMailnumber());
           System.out.println("Subject="+list.get(i).getSubject());
           System.out.println("Content="+list.get(i).getContent());
           System.out.println("Filename="+list.get(i).getFilename());
           System.out.println("SentDate="+list.get(i).getSentdate());
           System.out.println("Messageid="+list.get(i).getMessageid());
           System.out.println("ExistsFile="+list.get(i).isExistsFile());
           System.out.println("Read="+list.get(i).isRead());
           System.out.println("Replysign="+list.get(i).isReplysign());
           for(int j=0;j<list.get(i).getReceivepath().length;j++){
               System.out.println("第"+j+1+"个附件的Receivepath="+list.get(i).getReceivepath()[j]);
           }
           System.out.println("FromAddress="+list.get(i).getFromAddress());
           System.out.println("ToAddress="+list.get(i).getToAddress());
       }
   }

}

posted @ 2011-10-19 00:17 abin 阅读(2894) | 评论 (1) | 编辑收藏

Java 发送邮件（多接收者和多附件）

//实体类：

/**
* 发送邮件的基本信息
* @author dell
*
*/
public class MailInfo implements java.io.Serializable{

   private String host;//发送邮件的主机号
   private String port;//发送邮件的端口号
   private String fromAddress;//发送邮件地址
   private String toAddress;//接收邮件地址
   private String username;//发送邮件用户的用户名
   private String password;//发送邮件用户的密码
   private String validate;//是否需要身份的验证:ture认证，false不认证信息
   private String subject;//邮件主题
   private String content;//邮件的内容,分为文本，超文本，html等形式
   private String[] filepath;//发送邮件的附件的位置
   private String[] sendAddress;
   private String filename;//发送邮件的附件显示的名称
   private String receivepath;//接收邮件的时候附件保存的路径
   private java.util.Date sentdate;
   private float filesize;
   private java.util.Date receivedate;
   private String mailauthor;//邮件作者
   private boolean read;//是否读过，true读过，false没有阅读过
   private boolean ExistsFile;//是否有附件true有，false没有
   private boolean replysign;//是否有回执
   private String messageid;//消息ID
   private int mailnumber;//邮件数目，一个用户的总邮件数


   public String[] getSendAddress() {
       return sendAddress;
   }
   public void setSendAddress(String[] sendAddress) {
       this.sendAddress = sendAddress;
   }
   public int getMailnumber() {
       return mailnumber;
   }
   public void setMailnumber(int mailnumber) {
       this.mailnumber = mailnumber;
   }
   public String getMessageid() {
       return messageid;
   }
   public void setMessageid(String messageid) {
       this.messageid = messageid;
   }
   public boolean isExistsFile() {
       return ExistsFile;
   }
   public boolean isRead() {
       return read;
   }
   public void setExistsFile(boolean existsFile) {
       ExistsFile = existsFile;
   }
   public void setRead(boolean read) {
       this.read = read;
   }
   public boolean isReplysign() {
       return replysign;
   }
   public void setReplysign(boolean replysign) {
       this.replysign = replysign;
   }
   public String getMailauthor() {
       return mailauthor;
   }
   public void setMailauthor(String mailauthor) {
       this.mailauthor = mailauthor;
   }
   public java.util.Date getReceivedate() {
       return receivedate;
   }
   public void setReceivedate(java.util.Date receivedate) {
       this.receivedate = receivedate;
   }

   public java.util.Date getSentdate() {
       return sentdate;
   }
   public void setSentdate(java.util.Date sentdate) {
       this.sentdate = sentdate;
   }

   public String[] getFilepath() {
       return filepath;
   }
   public void setFilepath(String[] filepath) {
       this.filepath = filepath;
   }
   public String getContent() {
       return content;
   }
   public String getFilename() {
       return filename;
   }
   public String getFromAddress() {
       return fromAddress;
   }
   public String getHost() {
       return host;
   }
   public String getPassword() {
       return password;
   }
   public String getPort() {
       return port;
   }
   public String getSubject() {
       return subject;
   }
   public String getToAddress() {
       return toAddress;
   }
   public String getUsername() {
       return username;
   }
   public void setContent(String content) {
       this.content = content;
   }
   public void setFilename(String filename) {
       this.filename = filename;
   }
   public void setFromAddress(String fromAddress) {
       this.fromAddress = fromAddress;
   }
   public void setHost(String host) {
       this.host = host;
   }
   public void setPassword(String password) {
       this.password = password;
   }
   public void setPort(String port) {
       this.port = port;
   }
   public void setSubject(String subject) {
       this.subject = subject;
   }
   public void setToAddress(String toAddress) {
       this.toAddress = toAddress;
   }
   public void setUsername(String username) {
       this.username = username;
   }
   public String getValidate() {
       return validate;
   }
   public void setValidate(String validate) {
       this.validate = validate;
   }
   public String getReceivepath() {
       return receivepath;
   }
   public void setReceivepath(String receivepath) {
       this.receivepath = receivepath;
   }
}

//发送邮件程序

import java.util.Properties;

import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.Multipart;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
import javax.mail.internet.MimeUtility;

public class SendMail {

   public boolean Send(MailInfo mailInfo)throws Exception{
       Properties props=new Properties();
       //设置发送邮件的邮件服务器的属性（这里使用网易的smtp服务器）
       props.put("mail.smtp.host", mailInfo.getHost());
       //需要经过授权，也就是有户名和密码的校验，这样才能通过验证（一定要有这一条）
       props.put("mail.smtp.auth", mailInfo.getValidate());
       Session session=Session.getDefaultInstance(props);// 用刚刚设置好的props对象构建一个session
//       session.setDebug(true);
       MimeMessage message=new MimeMessage(session);
       try{
           message.setFrom(new InternetAddress(mailInfo.getFromAddress()));
           InternetAddress[] sendTo = new InternetAddress[mailInfo.getSendAddress().length];
           for(int i=0;i<mailInfo.getSendAddress().length;i++){
               sendTo[i]=new InternetAddress(mailInfo.getSendAddress()[i]);
           }
//           message.addRecipient(Message.RecipientType.TO, new InternetAddress(mailInfo.getToAddress()));
           message.setRecipients(Message.RecipientType.TO, sendTo);
           message.setSubject(mailInfo.getSubject());
           message.setSentDate(mailInfo.getSentdate());
           //向multipart对象中添加邮件的各个部分内容，包括文本内容和附件
           Multipart multipart=new MimeMultipart();
           BodyPart contentPart=new MimeBodyPart();
           contentPart.setText(mailInfo.getContent());
           multipart.addBodyPart(contentPart);
           //添加附件
           for(int i=0;i<mailInfo.getFilepath().length;i++){
               BodyPart messageBodyPart=new MimeBodyPart();
               String fpath=mailInfo.getFilepath()[i].split(",")[0];
               DataSource source=new FileDataSource(fpath);
               messageBodyPart.setDataHandler(new DataHandler(source));
               sun.misc.BASE64Encoder enc=new sun.misc.BASE64Encoder();
               String lname=fpath.substring(fpath.lastIndexOf("."), fpath.length());
               String fname=String.valueOf(System.currentTimeMillis())+lname;
               messageBodyPart.setFileName("=?GBK?B?"+enc.encode(fname.getBytes())+"?=");
               multipart.addBodyPart(messageBodyPart);
           }


           message.setContent(multipart);//text/plain表示纯文本内容
           message.saveChanges();
           Transport transport=session.getTransport("smtp");
           transport.connect(mailInfo.getHost(),mailInfo.getUsername(),mailInfo.getPassword());
           transport.sendMessage(message,message.getAllRecipients());
           transport.close();
           return true;
       }catch(Exception e){
           e.printStackTrace();
       }

       return false;
   }
}

//测试代码：

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class SendTest {
   @Test
   public void mailTest(){
       SendMail mail=new SendMail();
       MailInfo mailInfo=new MailInfo();
       mailInfo.setContent("邮件内容44444444444444444444");
       String[] filepath=new String[]{"D:\\1317742305879.csv","D:\\zpssoa.log","E:\\Emotion\\Photo\\好寂寞好空虚.gif"};
       mailInfo.setFilepath(filepath);
//       mailInfo.setFilename("希望"+fname);
       mailInfo.setFromAddress("leeposter@126.com");
       mailInfo.setHost("smtp.126.com");
       mailInfo.setSubject("邮件主题444444444444444444444");
//       mailInfo.setToAddress("liposter@163.com");
       String[] destination=new String[]{"liposter@163.com","lposter@163.com","liposter@126.com"};
       mailInfo.setSendAddress(destination);
       mailInfo.setUsername("leeposter");
       mailInfo.setValidate("true");
       mailInfo.setPassword("****");
       try{
           boolean flag=mail.Send(mailInfo);
           if(flag==true){
               System.out.println("发送成功");
           }else{
               System.out.println("发送失败");
           }
       }catch(Exception e){
           e.printStackTrace();
       }
   }
}

posted @ 2011-10-18 23:28 abin 阅读(1380) | 评论 (0) | 编辑收藏

Java 接收邮件(解码技术和附件接收)

邮件发送和接收已经全部实现，大家在转发市请注明出处(我这也是参考了N多大牛的作品)：

http://www.blogjava.net/stevenjohn/archive/2011/10/17/361491.html

//附件接收实现代码：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Properties;

import javax.mail.BodyPart;
import javax.mail.Flags;
import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Multipart;
import javax.mail.Part;
import javax.mail.Session;
import javax.mail.Store;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeUtility;

/**
* @author Administrator
*
*/
public class PraseMimeMessage {
   private MimeMessage mimeMessage = null;

   private String saveAttachPath = "d:\\";// 附件下载后的存放目录

   private StringBuffer bodytext = new StringBuffer();

   // 存放邮件内容的StringBuffer对象
   private String dateformat = "yy-MM-dd　HH:mm";// 默认的日前显示格式

   /**
   * 构造函数,初始化一个MimeMessage对象
   */
   public PraseMimeMessage() {
   }

   public PraseMimeMessage(MimeMessage mimeMessage) {
       this.mimeMessage = mimeMessage;
//       System.out.println("create　a　PraseMimeMessage　object........");
   }

   public void setMimeMessage(MimeMessage mimeMessage) {
       this.mimeMessage = mimeMessage;
   }

   /**
   *
   * 获取发件人的姓名和密码
   *
   * @return
   */
   public String getFrom() throws Exception {
       InternetAddress address[] = (InternetAddress[]) mimeMessage.getFrom();
       String from = address[0].getAddress();
       if (from == null)
           from = "";
       String personal = address[0].getPersonal();
       if (personal == null)
           personal = "";
       String fromaddr = personal + "<" + from + ">";
       return fromaddr;
   }

   /**
   * 获得邮件的收件人，抄送，和密送的地址和姓名，根据所传递的参数的不同 "to"----收件人 "cc"---抄送人地址 "bcc"---密送人地址
   */

   public String getMailAddress(String type) throws Exception {
       String mailaddr = "";
       String addtype = type.toUpperCase();
       InternetAddress[] address = null;
       if (addtype.equals("TO") || addtype.equals("CC")
               || addtype.equals("BCC"))

       {
           if (addtype.equals("TO")) {
               address = (InternetAddress[]) mimeMessage
                       .getRecipients(Message.RecipientType.TO);
           } else if (addtype.equals("CC")) {
               address = (InternetAddress[]) mimeMessage
                       .getRecipients(Message.RecipientType.CC);
           } else {
               address = (InternetAddress[]) mimeMessage
                       .getRecipients(Message.RecipientType.BCC);
           }
           if (address != null) {
               for (int i = 0; i < address.length; i++) {
                   String email = address[i].getAddress();
                   if (email == null)
                       email = "";
                   else {
                       email = MimeUtility.decodeText(email);
                   }
                   String personal = address[i].getPersonal();
                   if (personal == null)
                       personal = "";
                   else {
                       personal = MimeUtility.decodeText(personal);
                   }
                   String compositeto = personal + "<" + email + ">";
                   mailaddr += "," + compositeto;
               }
               mailaddr = mailaddr.substring(1);
           }
       } else {
           throw new Exception("Error　emailaddr　type!");
       }
       return mailaddr;
   }

   /**
   *
   * 获取邮件主题
   */
   public String getSubject() throws MessagingException {
       String subject = "";
       try {
           subject = MimeUtility.decodeText(mimeMessage.getSubject());
           if (subject == null)
               subject = "";
       } catch (Exception exce) {
       }
       return subject;
   }

   /*
   * 获取邮件发送日期
   *
   */

   public java.util.Date getSentDate() throws Exception {
       Date sentdate = mimeMessage.getSentDate();
       SimpleDateFormat format = new SimpleDateFormat(dateformat);
       return sentdate;
   }

   /**
   * 获取邮件正文
   *
   * @return
   *
   */

   public String getBodyText() {
       return bodytext.toString();
   }

   /**
   * 解析邮件，把得到的邮件内容保存到一个StringBuffer对象中，解析邮件主要是根据MimeType类型的不同执行不同的操作，一步一步的解析
   *
   *
   */

   public void getMailContent(Part part) throws Exception {
       String contenttype = part.getContentType();
       int nameindex = contenttype.indexOf("name");
       boolean conname = false;
       if (nameindex != -1)
           conname = true;
//       System.out.println("CONTENTTYPE:　" + contenttype);
       if (part.isMimeType("text/plain") && !conname) {
           bodytext.append((String) part.getContent());
       } else if (part.isMimeType("text/html") && !conname) {
           bodytext.append((String) part.getContent());
       } else if (part.isMimeType("multipart/*")) {
           Multipart multipart = (Multipart) part.getContent();
           int counts = multipart.getCount();
           for (int i = 0; i < counts; i++) {
               getMailContent(multipart.getBodyPart(i));
           }
       } else if (part.isMimeType("message/rfc822")) {
           getMailContent((Part) part.getContent());
       } else {
       }
   }

   /**
   *
   * 判断此邮件是否需要回执，如果需要回执返回"true",否则返回"false"
   *
   */

   public boolean getReplySign() throws MessagingException {
       boolean replysign = false;
       String needreply[] = mimeMessage
               .getHeader("Disposition-Notification-To");
       if (needreply != null) {
           replysign = true;
       }
       return replysign;
   }

   /*
   * 获得此邮件的Message-ID
   *
   */

   public String getMessageId() throws MessagingException {
       return mimeMessage.getMessageID();
   }

   /*
   * 【判断此邮件是否已读，如果未读返回返回false,反之返回true】
   *
   */

   public boolean isNew() throws MessagingException {
       boolean isnew = false;
       Flags flags = ((Message) mimeMessage).getFlags();
       Flags.Flag[] flag = flags.getSystemFlags();
//       System.out.println("flags's　length:　" + flag.length);
       for (int i = 0; i < flag.length; i++) {
           if (flag[i] == Flags.Flag.SEEN) {
               isnew = true;
//               System.out.println("seen　Message.......");
               break;
           }
       }
       return isnew;
   }

   /**
   *
   * 判断此邮件是否包含附件
   *
   */

   public boolean isContainAttach(Part part) throws Exception {
       boolean attachflag = false;
       String contentType = part.getContentType();
       if (part.isMimeType("multipart/*")) {
           Multipart mp = (Multipart) part.getContent();
           for (int i = 0; i < mp.getCount(); i++) {
               BodyPart mpart = mp.getBodyPart(i);
               String disposition = mpart.getDisposition();
               if ((disposition != null)
                       && ((disposition.equals(Part.ATTACHMENT)) || (disposition
                               .equals(Part.INLINE))))
                   attachflag = true;
               else if (mpart.isMimeType("multipart/*")) {
                   attachflag = isContainAttach((Part) mpart);
               } else {
                   String contype = mpart.getContentType();
                   if (contype.toLowerCase().indexOf("application") != -1)
                       attachflag = true;
                   if (contype.toLowerCase().indexOf("name") != -1)
                       attachflag = true;
               }
           }
       } else if (part.isMimeType("message/rfc822")) {
           attachflag = isContainAttach((Part) part.getContent());
       }
       return attachflag;
   }
    //base64解码
    private static String base64Decoder(String s) throws Exception {
        sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
        byte[] b = decoder.decodeBuffer(s);
        return (new String(b));
    }

   /*
   * 保存附件
   *
   */
   public String saveAttachMent(Part part) throws Exception {
       String fileName = "";
       if (part.isMimeType("multipart/*")) {
           Multipart mp = (Multipart) part.getContent();
           for (int i = 0; i < mp.getCount(); i++) {
               BodyPart mpart = mp.getBodyPart(i);
               String disposition = mpart.getDisposition();
               if ((disposition != null)
                       && ((disposition.equals(Part.ATTACHMENT)) || (disposition
                               .equals(Part.INLINE)))) {
                   fileName = mpart.getFileName();
                   /*System.out.println(fileName);
                   fileName=fileName.substring(fileName.indexOf("=?GBK?B?"));
                   System.out.println(fileName);
                   fileName=fileName.substring(0, fileName.length()-2);
                   System.out.println(fileName);*/
//                   .substring(fileName.lastIndexOf("=?GBK?B?"), fileName.indexOf("?="));
                     String s = fileName.substring(8, fileName.indexOf("?="));;
                     fileName = base64Decoder(s);
                   if (fileName.toLowerCase().indexOf("gb2312") != -1) {
                       fileName = MimeUtility.decodeText(fileName);
                   }
                   // saveFile(fileName,mpart.getInputStream());
                   saveFile(fileName, mpart.getInputStream());

               } else if (mpart.isMimeType("multipart/*")) {
                   saveAttachMent(mpart);
               } else {
                   fileName = mpart.getFileName();
                   if ((fileName != null)
                           && (fileName.toLowerCase().indexOf("GB2312") != -1)) {
                       fileName = MimeUtility.decodeText(fileName);
                       saveFile(fileName, mpart.getInputStream());
                   }
               }
           }
       } else if (part.isMimeType("message/rfc822")) {
           saveAttachMent((Part) part.getContent());
       }
       return fileName;
   }

   /**
   * 【设置附件存放路径】
   */

   public void setAttachPath(String attachpath) {
       this.saveAttachPath = attachpath;
   }

   /**
   *
   * 设置日期显示本格式
   */
   public void setDateFormat(String format) throws Exception {
       this.dateformat = format;
   }

   /**
   * 【获得附件存放路径】
   */

   public String getAttachPath() {
       return saveAttachPath;
   }

   /**
   * 【真正的保存附件到指定目录里】
   */

   private void saveFile(String fileName, InputStream in) throws Exception {

       String osName = System.getProperty("os.name");
       String storedir = getAttachPath();
       String separator = "";
       if (osName == null)
           osName = "";
       if (osName.toLowerCase().indexOf("win") != -1) {
           separator = "\\";
           if (storedir == null || storedir.equals(""))
               storedir = "c:\\tmp";
       } else {
           separator = "/";
           storedir = "/tmp";
       }
       File storefile = new File(storedir + separator + fileName);
//       System.out.println("storefile's　path:　" + storefile.toString());

       BufferedOutputStream bos = null;
       BufferedInputStream bis = null;
       try {
           bos = new BufferedOutputStream(new FileOutputStream(storefile));
           bis = new BufferedInputStream(in);
           int c;
           while ((c = bis.read()) != -1) {
               bos.write(c);
               bos.flush();
           }
       } catch (Exception exception) {
           exception.printStackTrace();
           throw new Exception("文件保存失败!");
       } finally {
           bos.close();
           bis.close();
       }
   }

   /**
   * PraseMimeMessage类测试
   */

   public static void main(String args[]) throws Exception {
       String host = "POP3.163.com";// 【POP3.163.com】
       String username = "li";// 【yuxia2217】
       String password = "***";// 【........】
       Properties props = new Properties();
       Session session = Session.getDefaultInstance(props, null);
       Store store = session.getStore("pop3");
       store.connect(host, username, password);
       Folder folder = store.getFolder("INBOX");
       folder.open(Folder.READ_ONLY);
       Message message[] = folder.getMessages();
       System.out.println("Messages's　length:　" + message.length);
       PraseMimeMessage pmm = null;
       for (int i = 0; i < message.length; i++) {
           pmm = new PraseMimeMessage((MimeMessage) message[i]);
           System.out
                   .println("Message　" + i + "　subject:　" + pmm.getSubject());
           System.out.println("Message　" + i + "　sentdate:　"
                   + pmm.getSentDate());
           System.out.println("Message　" + i + "　replysign:　"
                   + pmm.getReplySign());
           System.out.println("Message　新的" + i + "　hasRead:　" + pmm.isNew());
           System.out.println("Message　附件" + i + "　　containAttachment:　"
                   + pmm.isContainAttach((Part) message[i]));
           System.out.println("Message　" + i + "　form:　" + pmm.getFrom());
           System.out.println("Message　" + i + "　to:　"
                   + pmm.getMailAddress("to"));
           System.out.println("Message　" + i + "　cc:　"
                   + pmm.getMailAddress("cc"));
           System.out.println("Message　" + i + "　bcc:　"
                   + pmm.getMailAddress("bcc"));
           pmm.setDateFormat("yy年MM月dd日　HH:mm");
           System.out.println("Message" + i + "　sentdate:　"
                   + pmm.getSentDate());
           System.out.println("Message　" + i + "　Message-ID:　"
                   + pmm.getMessageId());
           pmm.getMailContent((Part) message[i]);
           System.out.println("Message　正文" + i + "　bodycontent:　\r\n"
                   + pmm.getBodyText());
           pmm.setAttachPath("D:\\image");
           pmm.saveAttachMent((Part) message[i]);


       }
   }
   public List<MailInfo> receive(MailInfo mailInfo)throws Exception{
       List<MailInfo> list=new ArrayList<MailInfo>();
       Properties props = new Properties();
       Session session = Session.getDefaultInstance(props, null);
       Store store = session.getStore("pop3");
       store.connect(mailInfo.getHost(), mailInfo.getUsername(), mailInfo.getPassword());
       Folder folder = store.getFolder("INBOX");
       folder.open(Folder.READ_ONLY);
       Message message[] = folder.getMessages();
   //   System.out.println("Messages's　length:　" + message.length);
       PraseMimeMessage pmm = null;
       for (int i = 0; i < message.length; i++) {
           MailInfo mail=new MailInfo();
           mail.setMailnumber(message.length);
           pmm = new PraseMimeMessage((MimeMessage) message[i]);
//           System.out
//                   .println("Message　" + i + "　subject:　" + pmm.getSubject());
           mail.setSubject(message[i].getSubject());
//           System.out.println("Message　" + i + "　sentdate:　"
//                   + pmm.getSentDate());
           mail.setSentdate(pmm.getSentDate());
//           System.out.println("Message　" + i + "　replysign:　"
//                   + pmm.getReplySign());
           mail.setReplysign(pmm.getReplySign());
//           System.out.println("Message　新的" + i + "　hasRead:　" + pmm.isNew());
//           mail.setRead(pmm.isNew());
//           System.out.println("Message　附件" + i + "　　containAttachment:　"
//                   + pmm.isContainAttach((Part) message[i]));
           mail.setExistsFile(pmm.isContainAttach((Part) message[i]));
//           System.out.println("Message　" + i + "　form:　" + pmm.getFrom());
           mail.setFromAddress(pmm.getFrom().substring(1, pmm.getFrom().length()).replaceAll(">", ""));
//           System.out.println("Message　" + i + "　to:　"
//                   + pmm.getMailAddress("to"));
           mail.setToAddress(pmm.getMailAddress("to").substring(1, pmm.getMailAddress("to").length()).replaceAll(">", ""));
//           System.out.println("Message　" + i + "　cc:　"
//                   + pmm.getMailAddress("cc"));
//           mail.setMailauthor(pmm.getMailAddress("cc"));
//           System.out.println("Message　" + i + "　bcc:　"
//                   + pmm.getMailAddress("bcc"));
           pmm.setDateFormat("yy年MM月dd日　HH:mm");
//           System.out.println("Message" + i + "　sentdate:　"
//                   + pmm.getSentDate());
//           System.out.println("Message　" + i + "　Message-ID:　"
//                   + pmm.getMessageId());
           mail.setMessageid(pmm.getMessageId());
           pmm.getMailContent((Part) message[i]);
//           System.out.println("Message　正文" + i + "　bodycontent:　\r\n"
//                   + pmm.getBodyText());
           mail.setContent(pmm.getBodyText());
           pmm.setAttachPath(mailInfo.getFilepath());
           String fileName=pmm.saveAttachMent((Part) message[i]);
           mail.setFilename(fileName);
           String receivepath=mailInfo.getFilepath()+"\\"+fileName;
           mail.setReceivepath(receivepath);
           list.add(mail);
   }
       return list;
}
}

//接收邮件测试类

import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
public class ReceiveTest{
   @Before
   public void setUp() throws Exception {
   }

   @After
   public void tearDown() throws Exception {
   }
   @Test
   public void ReceiveMailTest()throws Exception{
       MailInfo mailInfo=new MailInfo();
       mailInfo.setHost("pop.163.com");
       mailInfo.setUsername("liposter");
       mailInfo.setPassword("**********");
       mailInfo.setFilepath("D:\\image");
       List<MailInfo> list=new PraseMimeMessage().receive(mailInfo);
       for(int i=0;i<list.size();i++){
           System.out.println("Mailnumber="+list.get(i).getMailnumber());
           System.out.println("Subject="+list.get(i).getSubject());
           System.out.println("Content="+list.get(i).getContent());
           System.out.println("Filename="+list.get(i).getFilename());
           System.out.println("SentDate="+list.get(i).getSentdate());
           System.out.println("Messageid="+list.get(i).getMessageid());
           System.out.println("ExistsFile="+list.get(i).isExistsFile());
           System.out.println("Read="+list.get(i).isRead());
           System.out.println("Replysign="+list.get(i).isReplysign());
           System.out.println("Receivepath="+list.get(i).getReceivepath());
           System.out.println("FromAddress="+list.get(i).getFromAddress());
           System.out.println("ToAddress="+list.get(i).getToAddress());
       }


   }

}

posted @ 2011-10-18 00:00 abin 阅读(3240) | 评论 (0) | 编辑收藏

Java 发送邮件(包含附件与编码加密技术)

邮件发送和接收已经全部实现，大家在转发市请注明出处(我这也是参考了N多大牛的作品)：

http://www.blogjava.net/stevenjohn/archive/2011/10/17/361491.html

//发送邮件类：

import java.util.Properties;

import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.Multipart;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
import javax.mail.internet.MimeUtility;

public class SendMail {

   public boolean Send(MailInfo mailInfo)throws Exception{
       Properties props=new Properties();
       //设置发送邮件的邮件服务器的属性（这里使用网易的smtp服务器）
       props.put("mail.smtp.host", mailInfo.getHost());
       //需要经过授权，也就是有户名和密码的校验，这样才能通过验证（一定要有这一条）
       props.put("mail.smtp.auth", mailInfo.getValidate());
       Session session=Session.getDefaultInstance(props);// 用刚刚设置好的props对象构建一个session
       session.setDebug(true);
       MimeMessage message=new MimeMessage(session);
       try{
           message.setFrom(new InternetAddress(mailInfo.getFromAddress()));
           message.addRecipient(Message.RecipientType.TO, new InternetAddress(mailInfo.getToAddress()));
           message.setSubject(mailInfo.getSubject());
           message.setSentDate(mailInfo.getSentdate());
           //向multipart对象中添加邮件的各个部分内容，包括文本内容和附件
           Multipart multipart=new MimeMultipart();
           BodyPart contentPart=new MimeBodyPart();
           contentPart.setText(mailInfo.getContent());
           multipart.addBodyPart(contentPart);
           //添加附件
           if(mailInfo.getFilepath()!=null){
               BodyPart messageBodyPart=new MimeBodyPart();
               DataSource source=new FileDataSource(mailInfo.getFilepath());

               messageBodyPart.setDataHandler(new DataHandler(source));
               sun.misc.BASE64Encoder enc=new sun.misc.BASE64Encoder();
               String fname=mailInfo.getFilename();
               if(fname!=null){
                   messageBodyPart.setFileName("=?GBK?B?"+enc.encode(fname.getBytes())+"?=");
           //       messageBodyPart.setFileName(MimeUtility.encodeText(fname));
                   multipart.addBodyPart(messageBodyPart);
               }else{
                   String lname=mailInfo.getFilepath().substring(mailInfo.getFilepath().lastIndexOf("\\")+1, mailInfo.getFilepath().length());
                   System.out.println(lname);
                   messageBodyPart.setFileName("=?GBK?B?"+enc.encode(lname.getBytes())+"?=");
           //       messageBodyPart.setFileName(MimeUtility.encodeText(lname));
                   multipart.addBodyPart(messageBodyPart);
               }

           }


           message.setContent(multipart);//text/plain表示纯文本内容
           message.saveChanges();
           Transport transport=session.getTransport("smtp");
           transport.connect(mailInfo.getHost(),mailInfo.getUsername(),mailInfo.getPassword());
           transport.sendMessage(message,message.getAllRecipients());
           transport.close();
           return true;
       }catch(Exception e){
           e.printStackTrace();
       }

       return false;
   }
}

//测试邮件发送类
import org.junit.After;

import org.junit.Before;
import org.junit.Test;

public class SendTest {

   @Before
   public void setUp() throws Exception {
   }

   @After
   public void tearDown() throws Exception {
   }
   @Test
   public void mailTest(){
       SendMail mail=new SendMail();
       MailInfo mailInfo=new MailInfo();
       mailInfo.setContent("邮件内容44444444444444444444");
       mailInfo.setFilepath("E:\\Emotion\\Photo\\乳沟.jpg");
       String fname=mailInfo.getFilepath().substring(mailInfo.getFilepath().lastIndexOf("."), mailInfo.getFilepath().length());
       System.out.println(fname);
//       mailInfo.setFilename("希望"+fname);
       mailInfo.setFromAddress("leeposter@163.com");
       mailInfo.setHost("smtp.163.com");
       mailInfo.setSubject("邮件主题444444444444444444444");
       mailInfo.setToAddress("liposter@163.com");
       mailInfo.setUsername("leeposter");
       mailInfo.setValidate("true");
       mailInfo.setPassword("*********");
       try{
           boolean flag=mail.Send(mailInfo);
           if(flag==true){
               System.out.println("发送成功");
           }else{
               System.out.println("发送失败");
           }
       }catch(Exception e){
           e.printStackTrace();
       }


   }

}

posted @ 2011-10-17 23:56 abin 阅读(1855) | 评论 (0) | 编辑收藏

DB2 常用sql语句

取出前三条记录：
select * from notebook fetch first 3 row only

posted @ 2011-09-25 23:32 abin 阅读(1844) | 评论 (2) | 编辑收藏

仅列出标题

少年阿宾

常用链接

留言簿(22)

我参与的团队

随笔分类

随笔档案

新闻分类

相册

搜索

最新评论

阅读排行榜

评论排行榜