In this article, I am going to write “how to send email with or w/o attachment via Gmail SMTP on SSL(Secure Socket Layer)”.
For Gmail SMTP, see this link
To run the below code, you need 2 jars.

1. activation.jar – Get it from here
   
2. mail.jar – Get it from here

Here is the code…

import java.io.File;
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.MessagingException;
import javax.mail.Multipart;
import javax.mail.PasswordAuthentication;
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;

public class MailerTest {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("mail.smtp.host", "smtp.gmail.com");
        props.put("mail.smtp.socketFactory.port", "465");
        props.put("mail.smtp.socketFactory.class",
                "javax.net.ssl.SSLSocketFactory");
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.port", "465");

        Session session = Session.getDefaultInstance(props,
                new javax.mail.Authenticator() {
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication("SenderEmailId","Password");
            }
        });

        try {

            Message message = new MimeMessage(session);
            message.setFrom(new InternetAddress("SenderEmailId"));
            message.setRecipients(Message.RecipientType.TO,
                    InternetAddress.parse("RecipientEmailId"));
            message.setSubject("Sample Mail with Attachment");
            BodyPart messageBodyPart = new MimeBodyPart();
            Multipart multipart = new MimeMultipart();
            File file = new File("file name with path");
            DataSource source = new FileDataSource(file);
            messageBodyPart.setDataHandler(new DataHandler(source));
            String filename = "filename";
            messageBodyPart.setFileName(filename);
            multipart.addBodyPart(messageBodyPart);
            BodyPart messageBodyPart2 = new MimeBodyPart();
            messageBodyPart2.setText("Hello User"+"\n\n"+"Enjoy Mail service from a Java App"+
                    "\n\n"+ "NB: Please don't reply to this mail. It is a system generated message.");
            multipart.addBodyPart(messageBodyPart2);
            message.setContent(multipart);

            Transport.send(message);

            System.out.println("Done");

        } catch (MessagingException e) {
            throw new RuntimeException(e);
        }
    }
}

*For complete reference of different kind of mail, you can see this link

I wrote this program in about a half hour, but I already had some basic knowledge of the Java Mail API. I made an Email Account object, figuring that would be the most efficient way of building this program.

import javax.mail.*
import javax.mail.internet.*

class GroovyEmailer {

    private String username, password, host = "smtp.gmail.com"

    GroovyEmailer() {
        username = ""
        password = ""
    }
    GroovyEmailer(String usename, String passcode) {
        username = usename
        password = passcode
    }
    void sendMail(String to, String subject, String message){
        def props = new Properties()
        propsput "mail.smtps.auth", "true"

        def session = SessiongetDefaultInstance props, null

        def msg = new MimeMessage(session)

        msg setSubject subject
        msg setText message
        msg addRecipient Message RecipientType.To, new InternetAddress(to, to)

        def transport = session getTransport "smtps"

        try {
            transport connect (host, username, password)
            transport sendMessage (msg, msg.getAllRecipients())
       }
        catch (Exception e) {
            println "Error"
       }
    }
}

The next class is just a runner:

class EmailRunner {

    static void main(String[] args) {

        def myScanner = new Scanner(System.in)

        print "Enter your gmail username :: "
        String email = myScanner nextLine()

        print "\nEnter your gmail password :: "
        String password = myScanner nextLine()

        print "\nEnter the address to send to :: "
        String to = myScanner nextLine()

        print "\nEnter the message subject :: "
        String subject = myScanner nextLine()

        print "\nEnter the message :: "
        String message = myScanner nextLine()

        def emailer = new GroovyEmailer(email, password)

        emailer.sendMail to, subject, message
    }
}

Here is the way, using following class  and its APIs one can send mail programmatically to end users.Here you go:

JAVA provides APIs if you wish to send mail through code. One can also utilize it to send excel sheet of selenium test case results via mail after the end of automation script execution.

you can download JAVA mail API from following URL:

http://www.oracle.com/technetwork/java/javamail/index.html

Steps:

Download the mail api jar from given site.

Create a project in Eclipse/Netbeans ide.

Add this jar into project.

create a class and copy the code snippet given below to your class.

use its methods into your custom class where you want to utilize it.

Here is the code sample:

package com.Testscript;

import java.util.Properties;

import javax.activation.DataHandler;

import javax.activation.DataSource;

import javax.activation.FileDataSource;

import javax.mail.Authenticator;

import javax.mail.BodyPart;

import javax.mail.Message;

import javax.mail.MessagingException;

import javax.mail.Multipart;

import javax.mail.PasswordAuthentication;

import javax.mail.Session;

import javax.mail.Transport;

import javax.mail.internet.AddressException;

import javax.mail.internet.InternetAddress;

import javax.mail.internet.MimeBodyPart;

import javax.mail.internet.MimeMessage;

import javax.mail.internet.MimeMultipart;

public class Mailsetup

{

//First Approach without authentication

Properties props = new Properties();

Authenticator auth;

// fill props with any information

Session session = Session.getInstance(props, null);

public void sendmail() throws MessagingException,AddressException

{

props = session.getProperties();

InternetAddress address = new InternetAddress(“sender’s mail address“);

InternetAddress RecipientAddress=new InternetAddress(“recipient’s address“);

MimeMessage message = new MimeMessage(session);

message.setContent(“Hello”, “text/plain”);

message.setSubject(“First”);

message.setFrom(address);

message.addRecipient(RecipientType.TO, RecipientAddress);

Transport.send(message);

}

public void main(String[] args)

{

try

{

sendmail();

}

catch (Exception e) {

// TODO: handle exception

e.printStackTrace();

}

}

The above mentioned approach is not recommended since mail sent without authentication may go into spam and end user will not come to know about it unless and until he/she checks her junk mailbox. Therefore use below mentioned approach to make sure that end user gets mail in his/her inbox.

//This is another approach with authentication

public void sendMail(String mailServer, String from, String[] to,String subject, String messageBody,String[] attachments) throws MessagingException, AddressException

{

/*

PasswordAuthentication authentication;

authentication = new PasswordAuthentication(“sender’s email address“, “sender’s password“);

*/

// Setup mail server

Properties props = System.getProperties();

// Setup mail server

props.put(“mail.smtp.host”, mailServer);

props.put(“mail.smtp.port”, port number);

props.put(“mail.transport.protocol”, “smtp”);

props.put(“mail.smtp.starttls.enable”, “true”);

props.put(“mail.smtp.auth”, “true”);

Authenticator auth = new MailAuthenticator();

// Get a mail session

//Session session = Session.getDefaultInstance(props,new MailAuthenticator());

Session session = Session.getDefaultInstance(props,auth);

// Define a new mail message

Message message = new MimeMessage(session);

message.setFrom(new InternetAddress(from));

message.setSubject(subject);

// Create a message part to represent the body text

BodyPart messageBodyPart = new MimeBodyPart();

messageBodyPart.setText(messageBody);

//use a MimeMultipart as we need to handle the file attachments

Multipart multipart = new MimeMultipart();

//add the message body to the mime message

multipart.addBodyPart(messageBodyPart);

// add any file attachments to the message

addAtachments(attachments, multipart);

// Put all message parts in the message

message.setContent(multipart);

// Send the message

for(int i=0;i<=to.length-1;i++)

{

message.setRecipient(Message.RecipientType.TO, new InternetAddress(to[i]));

Transport.send(message);

}

System.out.println(“Mail Sent”);

}

protected void addAtachments(String[] attachments, Multipart multipart)

throws MessagingException, AddressException

{

for(int i = 0; i<= attachments.length -1; i++)

{

String filename = attachments[i];

MimeBodyPart attachmentBodyPart = new MimeBodyPart();

//use a JAF FileDataSource as it does MIME type detection

DataSource source = new FileDataSource(filename);

attachmentBodyPart.setDataHandler(new DataHandler(source));

//assume that the filename you want to send is the same as the

//actual file name – could alter this to remove the file path

attachmentBodyPart.setFileName(filename);

//add the attachment

multipart.addBodyPart(attachmentBodyPart);

}

}

public static void main(String[] args)

{

try

{

Mailsetup client = new Mailsetup();

String server=”mail server host address“;

String[] to={“recipient’s email address“};//one can add more than one address here to send mail to multiple recipients.

String from = “sender’s email address“;

String subject=”Automation Test Result”;

String message=”Hi This is for testing.”;

String[] filenames ={“attachment filepath“};

client.sendMail(server,from,to,subject,message,filenames);

}

catch(Exception e)

{

e.printStackTrace();

}

}

}

class MailAuthenticator extends Authenticator {

public MailAuthenticator() {

}

public PasswordAuthentication getPasswordAuthentication() {

return new PasswordAuthentication(“email address“, “password“);

}

}

Listing 1 – Maven dependency

<repositories>
        <repository>
            <id>Java.Net</id>
            <url>http://download.java.net/maven/2/</url>
        </repository>
    </repositories>
  
    <dependencies>
        <dependency>
	 <groupId>javax.mail</groupId>
	 <artifactId>mail</artifactId>
	 <version>1.4.3</version>
        </dependency> 
    </dependencies>

Listing 2 – GMail.java

package com.mycompany.employee.utils;

import java.io.UnsupportedEncodingException;
import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

/**
 * @author Mlungisi
 *
 */
public class GMail {

    public static void sendMail(String senderEmail, String recipientEmail, String subject, String message) throws MessagingException, UnsupportedEncodingException {
        // TLS
        Properties propsTLS = new Properties();
        propsTLS.put("mail.transport.protocol", "smtp");
        propsTLS.put("mail.smtp.host", "smtp.gmail.com");
        propsTLS.put("mail.smtp.auth", "true");
        propsTLS.put("mail.smtp.starttls.enable", "true"); // GMail requires STARTTLS

        Session sessionTLS = Session.getInstance(propsTLS);
        sessionTLS.setDebug(true);

        Message messageTLS = new MimeMessage(sessionTLS);
        messageTLS.setFrom(new InternetAddress("yourgmail@gmail.com", "Mlungisi Sincuba"));
        messageTLS.setRecipients(Message.RecipientType.TO, InternetAddress.parse("yourgmail@gmail.com")); // real recipient
        messageTLS.setSubject("Test mail using TLS");
        messageTLS.setText("This is test email sent to Your account using TLS.");

        Transport transportTLS = sessionTLS.getTransport();
        transportTLS.connect("smtp.gmail.com", 587, "yourgmail@gmail.com", "yourpassword"); // account used
        transportTLS.sendMessage(messageTLS, messageTLS.getAllRecipients());
        transportTLS.close();

        System.out.println("TLS done.");
        System.out.println("------------------------------------------------------------------------");

        // SSL			
        Properties propsSSL = new Properties();
        propsSSL.put("mail.transport.protocol", "smtps");
        propsSSL.put("mail.smtps.host", "smtp.gmail.com");
        propsSSL.put("mail.smtps.auth", "true");

        Session sessionSSL = Session.getInstance(propsSSL);
        sessionSSL.setDebug(true);

        Message messageSSL = new MimeMessage(sessionSSL);
        messageSSL.setFrom(new InternetAddress("yourgmail@gmail.com", "Mlungisi Sincuba"));
        messageSSL.setRecipients(Message.RecipientType.TO, InternetAddress.parse("yourgmail@gmail.com")); // real recipient
        messageSSL.setSubject("Test mail using SSL");
        messageSSL.setText("This is test email sent to Your account using SSL.");

        Transport transportSSL = sessionSSL.getTransport();
        transportSSL.connect("smtp.gmail.com", 465, "yourgmail@gmail.com", "yourpassword"); // account used
        transportSSL.sendMessage(messageSSL, messageSSL.getAllRecipients());
        transportSSL.close();

        System.out.println("SSL done.");
        System.out.println("------------------------------------------------------------------------");

    }

    public static void main(String[] args) throws MessagingException, UnsupportedEncodingException {
        System.out.println("Hello World!");
        sendMail(null, null, null, null);
    }
}

telnet <email_server_hostname> 25
S: 220 smtp.example.com ESMTP Postfix
C: HELO something.com
S: 250 Hello relay.example.org, I am glad to meet you
C: MAIL FROM: someone@something.com
S: 250 Ok
C: RCPT TO:radu@gmail.com
S: 250 Ok
C: RCPT TO:someoneyoumightwanttocc@gmail.com
S: 250 Ok
C: DATA
S: 354 End data with “.”
C: From: “Bob Example” <bob@example.org>
C: To: “Alice Example” <alice@example.com>
C: Cc: theboss@something.com
C: Date: Tue, 15 Jan 2008 16:02:43 -0500
C: Subject: Test message
C:
C: Hello Radu,
C: This is a test message with 5 header fields and 4 lines in the message body.
C: Your friend,
C: Someone
C: .
S: 250 Ok: queued as 12345
C: QUIT
S: 221 Bye
{The server closes the connection}

Enjoy!

To set up your email alerts you will need to cover these main steps:

1. In our specific case of email notifications, you need to set up a JavaMailSession object, that will actually be used by the Notifications to send the alerts through the specified email server;
2. Set up a diagnostic module and define any metrics that you would like to collect;
3. Define the Watches you are interested in – this is the situation that you want to trigger your alert. It can be a certain message in the log files, or a certain value of a collected metric, or a certain event occurring in the system.
4. Define the Notifications you would like to receive and associate the Watch to a Notification;

In the below example, we will set up alerts on the state of the Weblogic Managed Server, so the admin will get a notification when a server is not in the RUNNING state.

1.       Set up the Mail Session object.

Note that the JavaMailSession itself does not offer email server capabilities, but it only provides the JavaMail API so that applications can send and receive email from an already existing server.

a)      Click “Lock & Edit” to acquire a configuration lock

b)      Expand Services -> Mail Sessions and click “New” to create a new Java Mail Session object

c)       Provide Name, JNDI Name and JavaMail Properties as follow:

Name – WLSAlertsMailSession

JNDI Name – WLSAlertsMailSession

(You may enter whatever value here, but it’s best to keep the same value for the two names)

JavaMail Properties:

mail.debug=”true” – not mandatory, but recommended should you want to troubleshoot why your alerts are not getting through

mail.smtp.port=25

mail.smtp.from=”soa_admin@example.com”

mail.smtp.host=email.server.example.com

d)      Click next to target the mail session to a server (either managed or AdminServer) and click finish. You need to do this so that the MailSession is exposed on the servers JNDI tree.

e)      Activate the changes by clicking “Activate Changes”.

You can actually test that your JavaMail properties are correct and that you can send email messages via the email server specified by following the steps described in this post: <link>

2.       Set up a Diagnostic Module and define a metric of interest as a Collected Metric.

a)      Expand Diagnostics -> Diagnostics Modules and click “New” to create a new diagnostics module. Provide a name and description.

Name – DiagModuleWLDF

Description – This is a WLDF module for testing email notifications

b)      Select the newly created module and select “Targets” tab. Select the appropriate server for target as before

c)       Click “Save” and “Activate”

d)      Click “Lock & Edit” to acquire a new configuration lock

e)      Click on the “Collected Metrics” tab and click “New”

f)       Select “ServerRuntime” and click “Next”

g)      Select “ServerRuntimeMBean” from the dropdown

h)      From the list of collected attributes select “State” and move it in the “Chosen” category; Click “Next”

i)        From the instances list select the servers you would like to be informed about by selecting an instances and moving it to the “Chosen” category

j)        Click “Finish”

k)      Click “Save” and “Activate”

Notice that this metric is collected at a configurable interval, by default 300000ms

3.       Set up a new Watch rule

a)      Click “Lock & Edit” to acquire a configuration lock

b)      Navigate to the diagnostic module created above (DiagModuleWLDF) and select the “Watches and Notifications” tab and “Watches” sub-tab (if not already selected)

c)       Click “New” to create a new Watch. Provide the name and select the type as “Collected Metrics”. Also make sure the watch is enabled.

Name – ServerStateWatch

d)      Click “Next”

e)      Click “Add Expressions”

f)       Ensure that “ServerRuntime” is selected and click “Next”

g)      From the dropdown, select “ServerRuntimeMBean” again. The click “Next”

h)      Select the instance for the appropriate server from the list for “Instance” and click “Next”

i)        For “Message Attribute” select “State”, “!=” for “Operator” and type “RUNNING” (all capital letters) for “Value”. Click “Finish” the Watch

j)        Activate the changes

This Watch will now be triggered every time the server state is other than RUNNING. Please note that this is dependent on the Collected Metric’s sampling period as well.

4.       Setting up the Notification and associating it with a certain Watch

a)      Click “Lock & Edit” to acquire a configuration lock

b)      Navigate to the diagnostic module created above and select the “Watches and Notifications” tab and “Notification” sub-tab

c)       Click “New” to create a new Notification

d)      Select “SMTP (E-Mail) for Type and click “Next”

e)      Provide a name – ServerStateNotification. The notification must be enabled, of course. Click “Next”.

f)       Configure the following properties for the “Config Notification – SMTP Properties” page

g)      Mail Session Name – WLSAlertsMailSession

h)      E-Mail Recipients – admin@example.com

i)        Click “Finish”.

j)        Activate the changes

To associate the watch and the notification:

a)      Click “Lock & Edit” to acquire a configuration lock

b)      Navigate to the diagnostic module created above (DiagModuleWLDF) and select the “Watches and Notifications” tab and “Watches” sub-tab (if not already selected)

c)       Select the watch you created earlier – ServerStateWatch

d)      Select the “Notifications” tab and move the “ServerStateNotification” from Available to Chosen

e)      Click “Save”

f)       Select the “Alarms” tab and select “Use an automatic reset alarm”. Set the “Automatic reset period” so that you don’t get spammed with alerts email  and click “Save”.

g)      Click “Activate Changes

And that’s it. Next time one of your servers is in a state other than RUNNING (and is picked up by the collected metric based on the sampled period), you will receive an email in the form of:

Of course, both the Subject and the Body of the mail can be customized in the Administration console, in the notification section.

Kikonf provides a set of configuration plugins for Tomcat, the following is a non explicit list:

tom.alog : Configure Access log Valves.
tom.datasrc : Configure DataSources.
tom.realm : Configure Realmes.
tom.env : Configure environment entries.
tom.trans : Configure Transactions.
tom.udbrsc : Configure UDB Databases.
tom.mailrsc : Configure Java ® Mail resources.
tom.beansc : Configure Java Bean resources.
tom.crtserver : Creates new Catalina Bases.
tom.crtcluster : Configure Clusters.
tom.httpconn : Configure HTTP Connections.
tom.ajpconn : Configure AJP Connections.
tom.aprconn : Configure APR Connections.
tom.context : Configure Contexts.

As explained on the Tomcat official WebSite at:
http://tomcat.apache.org/tomcat-5.5-doc/config/context.html
Tomcat configurations can be handle at many scopes.

For example a dataSource may be configured at the Context level into :

- The <CATALINA_BASE>/conf/server.xml file.
- The default <CATALINA_BASE>/conf/context.xml file.
- A default context file for a guiven engine/host at :
<CATALINA_BASE>/conf/<ENGINE_NAME>/<HOSTNAME>/context.xml.default.xml.
- A root context file at <CATALINA_BASE>/conf/<ENGINE_NAME>/&l;tHOSTNAME>ROOT.xml
- A named context file at <CATALINA_BASE>/conf/<ENGINE_NAME>/<HOSTNAME>/<CONTEXT_NAME>.xml

Another example is the Access log Valves that supports the same scopes than before, but can also be configured at the Engine and Host levels.

This tutorial shows you, how to target those many scopes using the special
Kikonf configuration feature: the tag: scope provided for every Kikonf Action.

The following tutorial relays on the Kikonf official documentation for the
scope tag and illustrates, as possible, using tom.alog.

…

A Scope always ends to a specific node into a Tomcat configuration file.
The following list all the scope supported by Kikonf.

a) cbase: <CATALINA_BASE>

The value for cbase is an absolute path to a CATALINA_BASE directory.
If not provided cbase takes it default from the software_tom_catalina_base property of the kikonf.attrs file.
If the software_tom_catalina_base property of the kikonf.attrs file is not provided, cbase takes its value from the software_tom_catalina_home.

You can set “cbase” for a custom directory that you have setup to serve a as Catalina Base.
e.g.:
<scope cbase=’/webapp/invoices’/>
All the kikonf Actions for Tomcat configurations will go to this directory.

b) service: <SERVIVE_NAME>

Rarely used, but this property allows to switch to another Service node of the <CATALINA_BASE>/conf/server.xml file, when more than one Service node are declared into server.xml.
If not provided the only existing Service node entry within server.xml is used for sub dependant scopes.
To force the default for this Scope alone force the service value to “*default”.

If you have many service entries into your server.xml file, you can target a specific one by using this Attribute:
e.g.:
<scope service=’my_service’/>

c) engine: <ENGINE_NAME>

Rarely used, but this property allows to switch to another Engine node of the <CATALINA_BASE>/conf/server.xml, when more than one Engine node are declared into server.xml.
If not provided the only existing Server node entry within server.xml is used for sub dependant scopes.
To force the default for this Scope alone force the engine value to “*default”.

If you have many engine entries into your server.xml file, you can target a specific one by using this Attribute:
e.g.:
<scope service=’my_engine’/>

Obviously you can combine scope Attributes together e.g.:
<scope service=’my_service’ engine=’my_engine’/>

host = <HOSTNAME>

This value is used either to setup a subset of configuration entries directly under
the host level into the the <CATALINA_BASE>/conf/server.xml or under the <CATALINA_BASE>/conf/<ENGINE_NAME>/<HOSTNAME>/*.xml file.
If not provided the default value is localhost, it is used for sub dependant scopes.
To force the default for this Scope alone force the host value to
“*default”.

If you have many host entries into your server.xml file, you can target a specific one by using this Attribute:
e.g.:
<scope host=’my_host’/>

Obviously you can combine scope Attributes together e.g.:
<scope service=’my_service’ engine=’my_engine’ host=’my_host’/&glt;

A sample with the tom.alog Action:
In a directory of your choice edit a file named: tom.alog.xml
e.g.:
$ vi /home/neil/tom.alog.xml
And set its content to:

	<alog type = 'action' directory = '/webapp/invoices/logs'>
	    <scope host='*default'/>
	</alog>

Run:
$ kikact -c /home/neil tom.alog -v4

This creates the following entry into my server.xml,
at node Service@name:Catalina/Engine@name:Catalina/Host@name:localhost :
<Valve className=’org.apache.catalina.valves.AccessLogValve’ directory=’/webapp/invoices/logs’/>

d) context: <CONTEXT_NAME>

The value is a Tomcat Context name.
‘*blank’ is the default (aka ROOT) context.
This Attribute can be used in conjunction with all other scopes (except context.default.*).
If set and context.global:true,\
the target is the Context node with name:CONTEXT_NAME within the
<CATALINA_BASE>/conf/<ENGINE_NAME>/<HOSTNAME>/server.xml file.
Else the target is the file named
<CATALINA_BASE>/conf/<ENGINE_NAME>/<HOSTNAME>/<CONTEXT_NAME>.xml

To target a specific context type:
e.g.:
<scope context=’my_context’/>

Sample with defaults :

Edit the file tom.alog.xml

	<alog type = 'action' directory = '/webapp/invoices/logs'>
	    <scope context='*blank'/>
	</alog>

Run:
$ kikact -c /home/neil tom.alog -v4

This sample targets the node: “Context”,
into the file <CATALINA_BASE>/conf/<ENGINE_NAME>/<HOSTNAME>/ROOT.xml.

Note:
—–
When scope@service is not provided and if there is only one “service” node instance into the file server.xml it is taken as default.
When scope@engine is not provided and if there is only one “engine” node instance into the file server.xml under the previous service node, it is taken as default.
When scope@host is not provided its turned to localhost as default.

Because I kept the default Tomcat server.xml file, my values are :
- service : Catalina
- engine : Catalina
And host is set to : localhost

So the target file is for me :
/usr/local/tomcat/Tomcat 5.5/conf/Catalina/localhost/ROOT.xml.

Where I find this entry :
<Valve className=’org.apache.catalina.valves.AccessLogValve’ directory=’/webapp/invoices/logs’/>
under the “Context” node.

Explicit sample :

	<alog type = 'action' directory = '/webapp/invoices/logs'>
	    <scope engine='my_engine' host='my_host' context='my_context'/>
	</alog>

This sample targets the node: “Context”,
into the file <CATALINA_BASE>/conf/my_engine/my_host/my_context.xml.

For me :
/usr/local/tomcat/Tomcat 5.5/conf/my_engine/my_host/my_context.xml

e) context.global: <true/false>

If true, scope@context must be set.
If true, the target is the Context node with name: CONTEXT_NAME within the file <CATALINA_BASE>/conf/server.xml.

Sample with defaults :

This sample targets the “Context” node into server.xml with path=”" (aka *blank).

	<alog type = 'action' directory = '/webapp/invoices/logs'>
	    <scope context='*blank' context.global='true'/>
	</alog>

So the target file is for me :
/usr/local/tomcat/Tomcat 5.5/conf/server.xml.

Where I find this entry :
<Valve className=’org.apache.catalina.valves.AccessLogValve’ directory=’/webapp/invoices/logs’/>
under the node Server/Service@name=Catalina/Engine@name=Catalina/Host@name=localhost/Context@path=”".

Explicit sample :

	<alog type = 'action' directory = '/webapp/invoices/logs'>
	    <scope  cbase='/webapp/invoices' engine='my_engine' host='my_host' context='my_context'/>
	</alog>

This sample targets the node: Server/Engine@name=my_engine/Host@name=my_host/Context@path=my_context,
into the file: /webapp/invoices/conf/server.xml.

f) context.default.global: <true/false>

If true, the target is the Context node within the file
<CATALINA_BASE>/conf/context.xml.

Sample :

This sample targets the “Context” node into file :
<CATALINA_BASE>/conf/context.xml.

<alog type = ‘action’ directory = ‘/webapp/invoices/logs’>
<scope context.default.global=’true’/>
</alog>

Note:
—–
When scope@service is not provided and if there is only one “service” node instance into the file server.xml it is taken as default.
When scope@engine is not provided and if there is only one “engine” node instance into the file server.xml under the previous service node, it is taken as default.
When scope@host is not provided its turned to localhost as default.

So the target file is for me :
/usr/local/tomcat/Tomcat 5.5/conf/context.xml.

Where I find this entry :
<Valve className=’org.apache.catalina.valves.AccessLogValve’ directory=’/webapp/invoices/logs’/>
under the “Context” node.

g) context.default: <true/false>

If true, the target is the Context node within the file
<CATALINA_BASE>/conf/<ENGINE_NAME>/<HOSTNAME>/context.xml.default.xml.

Sample :

	<alog type = 'action' directory = '/webapp/invoices/logs'>
	    <scope context.default='true'/>
	</alog>

This sample targets the “Context” node into file :
<CATALINA_BASE>/conf/<ENGINE_NAME>/<HOSTNAME>/context.xml.default.xml.

Note:
—–
When scope@service is not provided and if there is only one “service” node instance into the file server.xml it is taken as default.
When scope@engine is not provided and if there is only one “engine” node instance into the file server.xml under the previous service node, it is taken as default.
When scope@host is not provided its turned to localhost as default.

So the target file is for me :
/usr/local/tomcat/Tomcat 5.5/conf/Catalina/localhost/context.xml.default.

Where I find this entry :
<Valve className=’org.apache.catalina.valves.AccessLogValve’ directory=’/webapp/invoices/logs’/>
under the “Context” node.

h) resources.global: <true/false>

If true will force the creation of a Resource node at the Tomcat GlobalNamingResources node of the <CATALINA_BASE>/conf/server.xml.
This is available for all the Resources supported by Kikionf Actions for Tomat (tom.udbrsc, tom.mailrsc, tom.beanrsc, tom.env).

As explained by the Tomcat official website at:
http://tomcat.apache.org/tomcat-5.5-doc/config/globalresources.html (chapter introduction), Tomcat 5 now support a new generic level to define resources within the server.xml file at :
the “GlobalNamingResources” level.
And these resources are not available by subsequent Contexts definition, until they define a ResourceLink tag.

The Kikonf Action allows you to define resources at this level specifying the resources.global=’true’ attribute.

Sample :

<env type = ‘action’ name = ‘env/currency’ etype = ‘java.lang.Float’>
<scope context=’*blank’ resources.global=’true’/>
<envrsc value = ’0.01′ override = ‘false’/>
</env>

This sample targets the “GlobalNamingResources” node into file :
/conf/server.xml.

So the target file is for me :
/usr/local/tomcat/Tomcat 5.5/conf/server.xml.

Where I find this entry :
<Environment name=’env/currency’ value=’0.01′ override=’false’ type=’java.lang.Float’/>
under the “GlobalNamingResources” node.

See also:
———
How to manage Apache Tomcat DataSources with kikonf
How to manage Apache Tomcat Environment entries with kikonf
How to manage Apache Tomcat Java Mail Resource with kikonf
How to manage Apache Tomcat Realms with kikonf
How to manage Apache Tomcat Access Logs with kikonf
How to manage Apache Tomcat Catalina Bases with kikonf

Trademarks:
___________

“Python” is a registered trademark of the Python Software Foundation.
“Apache”, “Apache Tomcat”, “Tomcat” and “Apache Derby” are trademarks of the Apache Software Foundation.
“Linux” is a trademark registred to Linus Torvalds
“JBoss Application Server” is a registered trademark of Red Hat and its affiliates in the U.S. and other countries.

Java is a registred trademark of Oracle and/or its affiliates.
Other names may be trademarks of their respective owners.

I ran this sample on Linux ®, but this works for any Python ® compliant O.S.

I. Before to start

a) Apache Tomcat installation
You should have Apache Tomcat >= 5.5 binary installed on your system.

b) Python installation
Python >=2.4.3 < 3 should also be installed.
If not download it from www.python.org

c) Kikonf installation
If you have not already installed kikonf

Go to www.kikonf.org/download.en.html and download the binary

Uncompress the file into some directory.
You should get something like: <my_directory>/kikonf-#-#
I choose to install it at /usr/local/kikonf-5.2.

Set the Kikonf binary path to your PATH environment variable.
e.g:
export PATH=$PATH:/usr/local/kikonf-5.2/bin

Typing:
$ kikact -h
or
$ kikact -H
should show the kikact help.

II. Edit the kikonf.attrs file to use your Tomcat binary installation

Go to the Kikonf conf directory: <my_directory>/kikonf-#-#/conf

$ cd /usr/local/kikonf-5.2/conf

And change the following lines to match the paths of your WebSphere installation:

# TOM : Tomcat (R) Injector #
#---------------------------#
software_tom_version = 5.5
software_tom_catalina_home = /usr/local/tomcat/Tomcat 5.5 # The tomcat Installation Directory.
# software_tom_catalina_base = /usr/local/tomcat/invoices
# (Optional) If software_tom_catalina_base is not specified, it take is value from software_tom_catalina_home.
# Note : software_tom_catalina_base can be overwrite by the tag scope/cbase in tom action files.
# software_tom_with_backup = True # (Optional, Default True) Do we backup the original files for the set of files updated at each configuration Session ?
# software_tom_backup_dir = /where/is/backup/dir # (Optional) Where to save the backuped files (If not the temp_dir is used).
# software_tom_record = False # (Optional, Default False) Do we want to record each configuration Session ?

III. Creating a Tomcat Java (*) Mail Resource

In a directory of your choice edit a file named: tom.mailrsc.xml
e.g.:
$ vi /home/neil/tom.mailrsc.xml

And set its content to:

<mailrsc
    type = 'action'
    name = 'mail/mymail'
>
    <scope context='*blank' context.global='true'/>
    <resource auth = 'false' host = 'mail.intra.net'/>    

</mailrsc>

Run:
$ kikact -c /home/neil tom.mailrsc -v4

kikact -c /home/neil  tom.mailrsc -v4

Begin Actions ...

picxmlp: Parsing file: /home/neil/tom.mailrsc.xml.
picxmlp: Parsing file: /usr/local/kikonf-5.2/kikonf-5.2/plugins/actions/tom/mailrsc/by/kikonf/ACT_INF/action.xml.
Begin Actions ...

Action:mailrsc retrieved.
   Inject Operation

      Mailrsc at scope: context.global
         cbase: /usr/local/tomcat/Tomcat 5.5
         context.global: true
         context:

         Java Mail Resource:mail/mymail Removing.
         Java Mail Resource:mail/mymail Creating.
         Java Mail Resource:mail/mymail Created.

... End Actions

File:/usr/local/tomcat/Tomcat 5.5/conf/server.xml saved !

This creates the following entry into my server.xml,
at node Service@name:Catalina/Engine@name:Catalina/Host@name:localhost/Context@path:” :
<Resource name=’mail/mymail’ auth=’Application’ mail.smtp.host=’mail.intra.net’ type=’javax.mail.Session’/>

IV. Creating a Tomcat DataSource as global resource and using it

As explained by the Tomcat official website at:
http://tomcat.apache.org/tomcat-5.5-doc/config/globalresources.html (chapter introduction),
Tomcat 5 now support a new generic level to define resources within the server.xml file at :
the “GlobalNamingResources” level.
And these resources are not available by subsequent Contexts definition, until they define a
ResourceLink tag.

The Kikonf Actions allows you to define resources at this level specifying the
resources.global=’true’ attribute.

In the same directory of your choice edit a file named: tom.mailrsc.$rg.xml
e.g.:
$ vi /home/neil/tom.mailrsc.$rg.xml

And set its content to:

<mailrsc
    type = 'action'
    name = 'mail/mymail'
>
    <scope context='*blank' context.global='true' resources.global='true'/>  
    <resource auth = 'false' host = 'mail.intra.net'/>   

    <link name = 'mail/local_name'/>
    
</mailrsc>

Run:
$ kikact -c /home/neil tom.mailrsc.$rg -v4

picxmlp: Parsing file: /home/neil/tom.mailrsc.$rg.xml.
picxmlp: Parsing file: /usr/local/kikonf-5.2/kikonf-5.2/plugins/actions/tom/mailrsc/by/kikonf/ACT_INF/action.xml.
Begin Actions ...

Action:mailrsc (tom.mailrsc.$rg) retrieved.
   Inject Operation

      Mailrsc at scope: context.global
         cbase: /usr/local/tomcat/Tomcat 5.5
         context.global: true
         context:
         resources.global: true

         Java Mail ResourceLink:mail/mymail Removing.
         Java Mail ResourceLink:mail/mymail Creating.
         Java Mail ResourceLink:mail/mymail Created.
         Java Mail Resource:mail/mymail Removing.
         Java Mail Resource:mail/mymail Creating.
         Java Mail Resource:mail/mymail Created.

... End Actions

File:/usr/local/tomcat/Tomcat 5.5/conf/server.xml saved !

This creates the following 2 entries into my server.xml :

- at the “GlobalNamingResources” level:
<Resource name=’mail/mymail’ auth=’Application’ mail.smtp.host=’mail.intra.net’ type=’javax.mail.Session’/>
- at node Service@name:Catalina/Engine@name:Catalina/Host@name:localhost/Context@path:” :
<ResourceLink global=’mail/mymail’ name=’mail/local_name’ type=’javax.mail.Session’/>

Note:
—–
This scope@resources.global facility is available for all the Resources supported by Kikonf Actions for Tomcat (tom.udbrsc, tom.mailrsc, tom.beanrsc, tom.env).

V. Handling scopes

This is a short example of the way of using the scope tag to target a Tomcat specific
scope.

To clearly understand the potential of this tag see the scope tutorial at:
==> Link sur tom.scopes

In the same directory of your choice edit a file named: tom.mailrsc.$scope.xml
e.g.:
$ vi /home/neil/tom.mailrsc.$scope.xml

And set its content to:
<mailrsc
type = ‘action’
name = ‘mail/mymail’
>
<scope context=’*blank’ resources.global=’true’/>
<resource auth = ‘false’ host = ‘mail.intra.net’/>

<link name = ‘mail/local_name’/>

</mailrsc>
Run:
$ kikact -c /home/neil tom.mailrsc.$scope -v4

Begin Actions ...

picxmlp: Parsing file: /home/neil/tom.mailrsc.$scope.xml.
picxmlp: Parsing file: /usr/local/kikonf-5.2/kikonf-5.2/plugins/actions/tom/mailrsc/by/kikonf/ACT_INF/action.xml.
Begin Actions ...

Action:mailrsc (tom.mailrsc.$scope) retrieved.
   Inject Operation

      Mailrsc at scope: context
         cbase: /usr/local/tomcat/Tomcat 5.5
         context:
         resources.global: true

         Java Mail ResourceLink:mail/mymail Removing.
         Java Mail ResourceLink:mail/mymail Removed:1 configuration Entry.
         Java Mail ResourceLink:mail/mymail Creating.
         Java Mail ResourceLink:mail/mymail Created.
         Java Mail Resource:mail/mymail Removing.
         Java Mail Resource:mail/mymail Removed:1 configuration Entry.
         Java Mail Resource:mail/mymail Creating.
         Java Mail Resource:mail/mymail Created.

... End Actions

File:/usr/local/tomcat/Tomcat 5.5/conf/Catalina/localhost/ROOT.xml saved !
File:/usr/local/tomcat/Tomcat 5.5/conf/server.xml saved !

Because scope@resources.global is true,
this creates one entry into my server.xml at the “GlobalNamingResources” level:
<Resource name=’mail/mymail’ auth=’Application’ mail.smtp.host=’mail.intra.net’ type=’javax.mail.Session’/>

Because scope@context.global is not given, hence false the target file is :
<CATALINA_BASE>/conf/<ENGINE_NAME>/<HOSTNAME>ROOT.xml
(for me /usr/local/tomcat/Tomcat 5.5/conf/Catalina/localhost/ROOT.xml)

Where this entry is created at the Context node :
<ResourceLink global=’mail/mymail’ name=’mail/local_name’ type=’javax.mail.Session’/>

Note:
—–
You may also change this path :
<CATALINA_BASE>/conf/<ENGINE_NAME>/<HOSTNAME>ROOT.xml
using :
<scope cbase=’/another/cbase’ engine=’my_engine’ host=’my_host’ context=’my_context’ resources.global=’true’/>
to:
/another/cbase/conf/my_engine/my_host/my_context.xml

See also:
——–
How to manage Apache Tomcat DataSources with kikonf
How to manage Apache Tomcat Environment entries with kikonf
How to manage Apache Tomcat Realms with kikonf
How to manage Apache Tomcat Scopes with kikonf
How to manage Apache Tomcat Access Logs with kikonf
How to manage Apache Tomcat Catalina Bases with kikonf

Trademarks:
___________
“Python” is a registered trademark of the Python Software Foundation.
“Apache”, “Apache Tomcat”, “Tomcat” and “Apache Derby” are trademarks of the Apache Software Foundation.
“Linux” is a trademark registered to Linus Torvalds
“JBoss Application Server” is a registered trademark of Red Hat and its affiliates in the U.S. and other countries.

Java is a registered trademark of Oracle and/or its affiliates.
Other names may be trademarks of their respective owners.

// hostIp : Mail server IP address,
//from : Mail from address (e.g xyz@domain.com)
//to : Mail to address (e.g abc@domain.com)
//cc : Mail CC address, bcc : mail to bcc address
//subject : mail subject,
//body : mail body,
//filename attachment file name including path
public boolean send(String hostIp,String from,String to,String cc,String bcc,String subject,String body,String filename)
{
String smtpHost=hostIp;
String host=”";
boolean status=false;
try {
Properties properties = System.getProperties ();
host=smtpHost;
properties.put(“mail.smtp.host”, host);
Session session = Session.getInstance(properties, null);
MimeMessage message = new MimeMessage(session);
if(from!=null) {
Address fromAddress = new InternetAddress(from);
message.setFrom(fromAddress);
}
// Parse and set the recipient addresses
if(to!=null) {
Address[] toAddresses = InternetAddress.parse(to);
message.setRecipients(Message.RecipientType.TO,toAddresses);
}
if(cc!=null) {
Address[] ccAddresses = InternetAddress.parse(cc);
message.setRecipients(Message.RecipientType.CC,ccAddresses);
}
if(bcc!=null) {
Address[] bccAddresses = InternetAddress.parse(bcc);
message.setRecipients(Message.RecipientType.BCC,bccAddresses);
}
// Set the subject and Body
message.setSubject(subject);
// Attach file with message
if(filename.equals(null)||filename.equals(“”))
{
/* MimeBodyPart mbp1 = new MimeBodyPart();
mbp1.setText(body);*/
BodyPart mbp1 = new MimeBodyPart();
mbp1.setContent(body, “text/html”);
// create the Multipart and its parts to it
Multipart mp = new MimeMultipart();
mp.addBodyPart(mbp1);
// add the Multipart to the message
message.setContent(mp);
}
else
{
File file = new File(filename);
if(file.exists())
{
/*MimeBodyPart mbp1 = new MimeBodyPart();
mbp1.setText(body);*/
BodyPart mbp1 = new MimeBodyPart();
mbp1.setContent(body, “text/html”);
// create the second message part
MimeBodyPart mbp2 = new MimeBodyPart();
// attach the file to the message
FileDataSource fds = new FileDataSource(filename);
mbp2.setDataHandler(new DataHandler(fds));
mbp2.setFileName(fds.getName());
// create the Multipart and its parts to it
Multipart mp = new MimeMultipart();
mp.addBodyPart(mbp1);
mp.addBodyPart(mbp2);
// add the Multipart to the message
message.setContent(mp);
}
else
{
/* MimeBodyPart mbp1 = new MimeBodyPart();
mbp1.setText(body);  */
BodyPart mbp1 = new MimeBodyPart();
mbp1.setContent(body, “text/html”);
// create the Multipart and its parts to it
Multipart mp = new MimeMultipart();
mp.addBodyPart(mbp1);
// add the Multipart to the message
message.setContent(mp);
}
}
// send the message
Transport.send(message);
status =true;
}catch (AddressException e){
status = false;
System.out.println(“Address field found corrupted.”);
}catch (SendFailedException e){
status = false;
System.out.println(“Unknown SMTP host: “+host);
}catch (MessagingException e) {
status = false;
System.out.println(“Could not connect to SMTP host:”+host);
}catch (Exception e) {
status = false;
System.out.println(“Could not connect to SMTP host:”+host);
}
return status;
}
public static void main(String[] args)  {
SendMail sendmail = new SendMail();
boolean t=sendmail.send(“your mail server IP”,”mailto:mailfrom@domain.com,mailto@domain.com,”",”",”Subject”,“body”,”c://abc.jpeg”);
System.out.print(t);
}
}

Application Settings

All application configurations will be given through the application.properties where you have to provide the settings like password, email list file, email file, return path, log file, debug option, mailer and mail format like text, html, etc..

Email Settings

Email settings file mainly contains all email settings which required by the Java Mailing apis, you may fine complete properties list here. some of the important properties ate are host, port, user name etc..

Application folder – contains all files

Setup Email List

Application property `application.list` used to pass the email list to the application. This file heaving a very simple format one line is equals to one email address. it means if you wanted to send email to 1000 people you have create 1000 lines in this file and place the complete path of that file in application.list parameter. default file is list.txt its already there with the program.

Setup Email

Application property `application.email` used to pass the email data to the application. You can write Text or HTML data in that file for the movement it does not support any attachments.

Setting Host and Port

Host and port both settings are related to the Email framework configurations, you may find the properties mail.smtp.host and mail.smtp.port in the email configurations. it varies based on which smtp server you are using. Here i have used an yahoo smtp server.

Setting User and Password

User and password are related to the different configurations, user is comes from the mail configurations while password is comes from the application configurations, as because mail configuration is a set of standard properties of Java Mail API not contains the property for the password. If you plan to send email using user/password authentication then mail.smtp.auth property must be set to true or else set to false if you plan to send email using local smtp program like sendmail.

Run Mass mail

Once you ready with all configurations, you just need to execute either run.sh or run.bat depending on your operating system. and It will start throwing email to the and logging the same in the logfile. Have a look at the sample run below.

Download

Click here to download the Application

Sample Run

mantavya@mga-laptop:~$ cd Desktop/massmail/
mantavya@mga-laptop:~/Desktop/massmail$ ./run.sh
19 Jun, 2011 1:30:19 PM in.mantavyagajjar.massmail.MailManager loadProperties
INFO: Read application settings application.properties successfully !
19 Jun, 2011 1:30:19 PM in.mantavyagajjar.massmail.MailManager loadProperties
INFO: Read mail settings mail.properties successfully !
19 Jun, 2011 1:30:19 PM in.mantavyagajjar.massmail.MailManager
INFO: Session created successfully !
19 Jun, 2011 1:30:19 PM in.mantavyagajjar.massmail.MailManager run
INFO: Reading emaillist list.txt successfully !
19 Jun, 2011 1:30:19 PM in.mantavyagajjar.massmail.MailManager run
INFO: Reading e-mail from email.txt successfully !
19 Jun, 2011 1:30:22 PM in.mantavyagajjar.massmail.MailManager run
INFO: Email sent successfully – mantavyagajjar@gmail.com

Properties props = System.getProperties();

.

.

.

Now the second thing which I needed to do was to send the excel file as an attachment in a mail to the user. My existing code used to support the text mail sending part but now I have to attach the excel file to it. I had generated an array of bytes to dispaly in excel file and now I wanted to use this byte array to be sent as an excel attachment.
When I googled I found solutions majorly related to wiring the file on disk as temp.xls and then reading the file , attaching it and then deleting the temp file which was actually I what I was trying to  avoid as I have never done file handling and some how I am bit scared of file I/O APIs.

Since I was using spring framework , we were using mimeMessageHelper for mails. I looked into the API’s and found out that it also supports attachment with mails and that even without using file I/O  I was able to use my array of bytes.
But there were few problems at first due to InputStreamSource class as I never used it before. Moreover, I did not find a single article on internet which described the whole process with a complete working example. So, I had to hop from one place to another on web to finally get to the solution.

I guess its a very general problem which many people would encounter, so I am giving a sample code which I will explain a bit also.

*******************************************************************************

public void sendBulkAttachMentTextEmail(final Collection<String> to, final String from,
final String subject, final String emailText,final byte[] byteArray)
throws MailServiceException {
MimeMessagePreparator preparator = new MimeMessagePreparator() {
public void prepare(MimeMessage mimeMessage) throws Exception {

MimeMessageHelper message = new MimeMessageHelper(mimeMessage,true);

// Get the array to addresses.
Object[] toAddresses = to.toArray();
int noOfRecipients = toAddresses.length;
String[] addressTo = new String[noOfRecipients];
for (int i = 0; i < noOfRecipients; i++) {
addressTo[i] = (String) toAddresses[i];
}

//Set message To address list.
message.setTo(addressTo);
logger.info(“Recipient : ” + addressTo);
//Set email from address.
message.setFrom(from);
logger.info(“Sender : ” + from);
//Set email subject
message.setSubject(subject);
logger.info(“Subject : ” + subject);

//parse the template and replace the variable values.
freeMarkerConfig.clearTemplateCache();
/*Template mailTemplate = freeMarkerConfig.getTemplate(template);
String text = FreeMarkerTemplateUtils
.processTemplateIntoString(mailTemplate, params);*/

logger.info(“Email Content : “);
//Set the email text.
logger.info(emailText);
message.setText(emailText, true);

ByteArrayResource bar = new ByteArrayResource(byteArray);

message.addAttachment(“Report.xls”,bar,”application/vnd.ms-excel “);

}
};

}

**************************************************************************

You must set the boolean to true in MimemessageHelper constructor. It means that you are defining the mail to be multipart.

Now Spring provides different class implementing InputStreamSource . Since I had the array of bytes I created an instance of ByteArrayResource with the argument in constructor as my byte[]. Lastly you need to define the report name and its type while attaching the ByterArrayResource instance and then you can send the mail.

I guess this information may be useful for people looking for this kind of task and if you have any questions you can put in your comments over here and I would revert back.

Thanks

Gaurav Mutreja

Download mail.jar and activation.jar,  and add them in the java class path to compile and run the code.

Sample Code for Single Part plain/text Email :

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

// Send a simple, single part, text/plain e-mail
public class SendTestEmail {

    public static void main(String[] args) {

        // SUBSTITUTE YOUR EMAIL ADDRESSES HERE!!!
        String to = "<usrname@domain.com>"; // i.e. ashish@gmail.com
        String from = "<username@domain.com>"; //i.e ashish@gmail.com
        // SUBSTITUTE YOUR ISP'S MAIL SERVER HERE!!!
        String host = "<host name>";  // i.g smtp.gmail.com for gmail

        // Create properties, get Session
        Properties props = new Properties();

        // If using static Transport.send(),
        // need to specify which host to send it to
        props.put("mail.smtp.host", host);
        // To see what is going on behind the scene
        props.put("mail.debug", "true");  // I have set debug  TRUE to see whats going on inside the JAVA MAIL. If you don'd need it turn it off.
        Session session = Session.getInstance(props);

        try {
            // Instantiatee a message
            Message msg = new MimeMessage(session);

            //Set message attributes
            msg.setFrom(new InternetAddress(from));
            InternetAddress[] address = {new InternetAddress(to)};
            msg.setRecipients(Message.RecipientType.TO, address);
            msg.setSubject("Test E-Mail through Java");
            msg.setSentDate(new Date());

            // Set message content
            msg.setText("This is a test of sending a " +
                        "plain text e-mail through Java.\n" +
                        "Here is line 2.");

            //Send the message
            Transport.send(msg);
        }
        catch (MessagingException mex) {
            // Prints all nested (chained) exceptions as well
            mex.printStackTrace();
        }
    }
}//End of class

 

Now compile and run the program after changing the Email addresses and Mail Server Address.

 This is the example of single part ,text.plain email. Now we will see a sample code for send mails having Multipart, Attachments or HTML contents.

Sample Code for  Multipart , HTML, Attachment Emails :

import java.util.*;
import java.io.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendTestEmail{
   private static final String SMTP_HOST_NAME = "<host name>";  //i.g. smtp.gmail.com
     private static final String SMTP_PORT = "465"; 
     private static final String emailFromAddress = "<userNameFrom@domain.com>";   //i.g. ashish@gmail.com
     private static final String SSL_FACTORY = "javax.net.ssl.SSLSocketFactory"; 
     private static final String sendTo = "<userNameTo@domain.com>" ;  //i.g. ashish@gmail.com
   
 public static void main(String[] args) {
          Properties props = new Properties(); 
          props.put("mail.smtp.host", SMTP_HOST_NAME); 
          props.put("mail.smtp.auth", "true"); 
          props.put("mail.debug", "true"); 
          props.put("mail.smtp.port", SMTP_PORT); 
          props.put("mail.smtp.socketFactory.port", SMTP_PORT); 
          props.put("mail.smtp.socketFactory.class", SSL_FACTORY); 
          props.put("mail.smtp.socketFactory.fallback", "false"); 
   
          props.put("mail.smtp.starttls.enable","true"); 
  // Get a session
  Session session = Session.getInstance(props);
  try {
   // Get a Transport object to send e-mail
   Transport bus = session.getTransport("smtp");
   bus.connect(SMTP_HOST_NAME, emailFromAddress, "changeme");
   // Instantiate a message
   Message msg = new MimeMessage(session);
   // Set message attributes
   msg.setFrom(new InternetAddress(emailFromAddress));
   InternetAddress[] address = { new InternetAddress(sendTo) };
   msg.setRecipients(Message.RecipientType.TO, address);
   // Parse a comma-separated list of email addresses. Be strict.
   msg.setRecipients(Message.RecipientType.CC, InternetAddress.parse(
     sendTo, true));
   // Parse comma/space-separated list. Cut some slack.
   msg.setRecipients(Message.RecipientType.BCC, InternetAddress.parse(
     sendTo, false));
   msg.setSubject("Test E-Mail through Java");
   msg.setSentDate(new Date());
   // Set message content and send
   //Send Multipart Eamil Message
   setMultipartContent(msg);
   msg.saveChanges();
   bus.sendMessage(msg, address);
   //Send Email with Attachment
   setFileAsAttachment(msg, "<file path>");
   msg.saveChanges();
   bus.sendMessage(msg, address);
   // Send HTML email
   setHTMLContent(msg);
   msg.saveChanges();
   bus.sendMessage(msg, address);
   bus.close();
  } catch (MessagingException mex) {
   // Prints all nested (chained) exceptions as well
   mex.printStackTrace();
   // How to access nested exceptions
   while (mex.getNextException() != null) {
    // Get next exception in chain
    Exception ex = mex.getNextException();
    ex.printStackTrace();
    if (!(ex instanceof MessagingException))
     break;
    else
     mex = (MessagingException) ex;
   }
  }
 }
 // A simple, single-part text/plain e-mail.
 public static void setTextContent(Message msg) throws MessagingException {
  // Set message content
  String mytxt = "This is a test of sending a "
    + "plain text e-mail through Java.\n" + "Here is line 2.";
  msg.setText(mytxt);
  // Alternate form
  msg.setContent(mytxt, "text/plain");
 }
 // A simple multipart/mixed e-mail. Both body parts are text/plain.
 public static void setMultipartContent(Message msg)
   throws MessagingException {
  // Create and fill first part
  MimeBodyPart p1 = new MimeBodyPart();
  p1.setText("This is part one of a test multipart e-mail.");
  // Create and fill second part
  MimeBodyPart p2 = new MimeBodyPart();
  // Here is how to set a charset on textual content
  p2.setText("This is the second part", "us-ascii");
  // Create the Multipart. Add BodyParts to it.
  Multipart mp = new MimeMultipart();
  mp.addBodyPart(p1);
  mp.addBodyPart(p2);
  // Set Multipart as the message's content
  msg.setContent(mp);
 }
 // Set a file as an attachment. Uses JAF FileDataSource.
 public static void setFileAsAttachment(Message msg, String filename)
   throws MessagingException {
  // Create and fill first part
  MimeBodyPart p1 = new MimeBodyPart();
  p1.setText("This is part one of a test multipart e-mail."
    + "The second part is file as an attachment");
  // Create second part
  MimeBodyPart p2 = new MimeBodyPart();
  // Put a file in the second part
  FileDataSource fds = new FileDataSource(filename);
  p2.setDataHandler(new DataHandler(fds));
  p2.setFileName(fds.getName());
  // Create the Multipart. Add BodyParts to it.
  Multipart mp = new MimeMultipart();
  mp.addBodyPart(p1);
  mp.addBodyPart(p2);
  // Set Multipart as the message's content
  msg.setContent(mp);
 }
 // Set a single part html content.
 // Sending data of any type is similar.
 public static void setHTMLContent(Message msg) throws MessagingException {
  String html = "<html><head><title>" + msg.getSubject()
    + "</title></head><body><h1>" + msg.getSubject()
    + "</h1><p>This is a test of sending an HTML e-mail"
    + " through Java.</body></html>";
  // HTMLDataSource is an inner class
  msg.setDataHandler(new DataHandler(new HTMLDataSource(html)));
 }
 /*
  * Inner class to act as a JAF datasource to send HTML e-mail content
  */
 static class HTMLDataSource implements DataSource {
  private String html;
  public HTMLDataSource(String htmlString) {
   html = htmlString;
  }
  // Return html string in an InputStream.
  // A new stream must be returned each time.
  public InputStream getInputStream() throws IOException {
   if (html == null)
    throw new IOException("Null HTML");
   return new ByteArrayInputStream(html.getBytes());
  }
  public OutputStream getOutputStream() throws IOException {
   throw new IOException("This DataHandler cannot write HTML");
  }
  public String getContentType() {
   return "text/html";
  }
  public String getName() {
   return "JAF text/html dataSource to send e-mail only";
  }
 }
} // End of class

This is the sample code for sending  email  of  type multipart, having attachments  and HTML content.

Compile and run the program after making necessary changes for email addresses of  To and From and Server Address , file path for attachment etc.

In next part i’ll provide the sample code for Fetching emails and Forwarding them to others.

Keep Coding  …

Ashish

import java.util.Properties;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

public class TestMail {
public static void main(String args[]) throws Exception {
String host = “localhost”;
String from = “nani@gmail.com”;
String to = “nani@gmail.com”;
String user = “mallik”;
String password = “mallik”;
String content = “Change your password.”;
Properties properties = System.getProperties();
properties.setProperty(“mail.smtp.host”, host);
Session session =Session.getDefaultInstance(properties);
MimeMessage message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
message.setSubject(“Test Mail”);
message.setText(content);

Transport.send(message);
System.out.println(“Message Send Successfully…” + content);

}
}

READING MAIL EXAMPLE

import java.io.*;
import java.util.*;
import javax.mail.*;

public class ReadMail {
public static void main(String args[]) throws Exception {
String host = “localhost”;
String user = “nani”;
String password = “nani”;
Properties properties = System.getProperties();
Session session = Session.getDefaultInstance (properties);
Store store = session.getStore(“pop3″);
store.connect(host, user, password);
Folder folder = store.getFolder(“inbox”);
folder.open(Folder.READ_ONLY);

Message[] message = folder.getMessages();

for (int i = 0; i < message.length; i++) {
System.out.println(“—– Message ” + (i + 1) + ” ————”);
System.out.println(“SentDate : ” + message[i]. getSentDate());
System.out.println(“From : ” + message[i]. getFrom()[0]);
System.out.println(“Subject : ” + message[i]. getSubject());
System.out.print(“Message : “);
InputStream stream = message[i]. getInputStream();
while (stream.available() != 0) {
System.out.print((char) stream.read());
}
}
folder.close(true);
store.close();
}
}

SENDIG MAIL WITH AN ATTACHMENT

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.SendFailedException;
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;

public class AttachExample {
public static void main (String args[]) throws Exception {
String host = “localhost”;
String from = “nani@gmail.com”;
String to[] = new String[]{“nani@gmail.com”,”gopikanthk”};
String filename = “testAttach.txt”;
// Get system properties
Properties props = System.getProperties();
props.put(“mail.smtp.host”, host);
Session session = Session.getInstance(props, null);
System.out.println(session.getProperties());
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));

InternetAddress[] toAddress = new InternetAddress[to.length];
for (int i = 0; i < to.length; i++){
toAddress[i] = new InternetAddress(to[i]);
System.out.println(“to address are——–”+toAddress[i]);
}
message.setRecipients(Message.RecipientType.TO, toAddress);
String a=null;
System.out.println(“recipent type to—-”);
message.setSubject(“Hello JavaMail Attachment”);
System.out.println(“After the subject———”);
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(“Here’s the file”);
System.out.println(“After the content of the message—-”);
Multipart multipart = new MimeMultipart();

multipart.addBodyPart(messageBodyPart);
messageBodyPart = new MimeBodyPart();

DataSource source = new FileDataSource(filename);

messageBodyPart.setDataHandler(new DataHandler(source));
System.out.println(“After the data handler—-”);
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);
message.setContent(multipart);
try{
System.out.println(“In try block——-”);
Transport.send(message);
System.out.println(“messages sent successfully………”);
}
catch(SendFailedException sfe)
{
message.setRecipients(Message.RecipientType.TO, sfe.getValidUnsentAddresses());
Transport.send(message);

}
}

}

SMTP Authenticator


/**
*
*/
package com.ashwin;

return new PasswordAuthentication(masteruser, masterpswd);
}
}


Sending an email from a JAVA application.

I’ve discovered another great tool this week – Febootimail.
It allows you to send an email from the command line – meaning that you can send an email from any JAVA application running on a windows OS. Not just basic emails, but HTML email, attachments etc.

STEP 1 Download & Install febootimail.exe:

The Febootimail application can be downloaded from the following location -
http://www.febooti.com/downloads/
and look for the setup / installer EXE.

Once downloaded run the setup process – the default setup location is C:\Program Files\febooti Command line email\

When the install is complete navigate to the install directory and look for a file called febootimail.exe.
This is the EXE that you will call from your JAVA application. If you only intend running your application on your local pc then this is fine. I run it from a server side application, so copied febootimail.exe to a server location accessible from all the clients running my JAVA app.

STEP 2 Call Febootimail.exe From the Application:

The following is an extract from a simple class that will send an email.

try{

          String cmd;

          cmd = “ C:\Program Files\febooti Command line email\febootimail.exe”; // LINE1

          cmd += ” -SERVER mail.yourserver.net”;//LINE 2

          cmd += ” -FROM info@yourdomain.co.uk”; // LINE 3

          cmd += ” -TO toaddress@whoever.com” ; // LINE 4

          cmd += ” -MSG This is the body of the email address”; // LINE 5

          cmd += ” -HTML “; // LINE 6

          cmd += ” -SUBJ This Is The Subject”; // LINE 7

          cmd += ” -FROMNAME fromaddress@yourdomain.com”; // LINE 8

          cmd += ” -AUTH AUTO -USER username -PASS password “; // LINE 9

          Process p = Runtime.getRuntime().exec(cmd);

}

catch(Exception e){

            e.printStackTrace();

}

Line 1: Points JAVA to febootimain.exe. Change the location depending on where you placed the exe.
Line 2:  Supply your mail server name.
Line 3: Supply a FROM address.
Line 4: the recipient email address.
Line 5: This is the message body. This could be HTML code.
Line 6: Tells febootimail.exe to expect HTML in the message body.
Line 7: Sets the subject.
Line 8: sets the from name – this will abear as the sender alias.
Line 9: The username and password for your mail server.

package com.webaging.utils;

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.MessagingException;
import javax.mail.Multipart;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;

/**
* @author Ashwin
*
*/
public class MailClient {

public void sendMail(String mailServer, String from, String to,
String subject, String messageBody, String[] attachments)
throws MessagingException, AddressException {
// Setup mail server
Properties props = System.getProperties();
props.put(“mail.smtp.host”, mailServer);

// Get a mail session
Session session = Session.getDefaultInstance(props, null);

// Define a new mail message
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress(from));
message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
message.setSubject(subject);

// Create a message part to represent the body text
BodyPart messageBodyPart = new MimeBodyPart();
messageBodyPart.setText(messageBody);

// use a MimeMultipart as we need to handle the file attachments
Multipart multipart = new MimeMultipart();

// add the message body to the mime message
multipart.addBodyPart(messageBodyPart);

// add any file attachments to the message
addAtachments(attachments, multipart);

// Put all message parts in the message
message.setContent(multipart);

// Send the message
Transport.send(message);

}

protected void addAtachments(String[] attachments, Multipart multipart)
throws MessagingException, AddressException {
for (int i = 0; i <= attachments.length – 1; i++) {
String filename = attachments[i];
MimeBodyPart attachmentBodyPart = new MimeBodyPart();

// use a JAF FileDataSource as it does MIME type detection
DataSource source = new FileDataSource(filename);
attachmentBodyPart.setDataHandler(new DataHandler(source));

// assume that the filename you want to send is the same as the
// actual file name – could alter this to remove the file path
attachmentBodyPart.setFileName(filename);

// add the attachment
multipart.addBodyPart(attachmentBodyPart);
}
}

public static void main(String[] args) {
try {
MailClient client = new MailClient();
String server = “pop3.mydomain.com”;
String from = “myname@mydomain.com”;
String to = “someuser@somewhere.com”;
String subject = “Test”;
String message = “Testing”;
String[] filenames = { “c:\\somefile.txt” };

client.sendMail(server, from, to, subject, message, filenames);
} catch (Exception e) {
e.printStackTrace(System.out);
}

}
}

Courtesy: http://www.osix.net/modules/article/?id=39