如何在Java平台上使用脚本语言做Java开发

def v1 = ‘66‘      // sets the variable with a value of type Stringprintln v1.dump()// prints out:// <[email protected] value=[6, 6] offset=0 count=2 hash=1728>

v1 = 9            // resets the variable with a value of type Integerprintln v1.dump()// prints out:// <[email protected] value=9>

def v1 = ‘66‘         // set v1 with a String typed valuedef v2 = 5            // set v2 with a Integer typed valuedef v3 = v1 + v2println v3// prints out: // 665

v1 = ‘66‘              # set v1 with a String typed valuev2 = 5                 # set v2 with a Integer typed valuev3 = v1 + v2# prints out:# TypeError: cannot concatenate ‘str‘ and ‘int‘ objects

// the call back handler definition        interface IDataHandler {                public boolean onData(INonBlockingConnection nbc) throws IOException;

        }        // the server receives data and performs the handler‘s call back method        class MultithreadedServer {                 private volatile boolean isRunning = true;                 private IDataHandler dataHandler = null;

                // accepts only an object which implements the IDataHandler interface                MultithreadedServer(IDataHandler dataHandler) {                        this.dataHandler = dataHandler;                }                public void run() {                       while (isRunning) {                           // waiting for data                           // ...                                       // ... and dispatch it                           dataHandler.onData(nbc);                       }                }        }        // the call back implementation        class SmtpProtocolHandler implements IDataHandler {                public boolean onData(INonBlockingConnection nbc) throws IOException {                     SmtpSession session = (SmtpSession) nbc.getAttachment();                     //...                }        }

        MultithreadedServer server = new MultithreadedServer(new SmtpProtocolHandler());        server.run();

// the call back implementation (which doesn‘t implement any interface)        class SmtpProtocolHandler {                def onData(nbc) {                     def session = nbc.attachment                     //...                 }        }

        def server = new MultithreadedServer(new SmtpProtocolHandler())        server.run()

// run a Ruby scripting  (JRuby V1.1b1)Ruby runtime = Ruby.getDefaultInstance();runtime.executeScript(scripting, filename);

// run a Groovy scripting (Groovy V1.1)GroovyShell gs = new GroovyShell();gs.evaluate(scripting);

// run a Python scripting (jython V2.2)PythonInterpreter interp = new PythonInterpreter();interp.exec(scripting)

include Java

# set up constants to shorten the pathsSSLContext = javax.net.ssl.SSLContextBlockingConnection = Java::org.xsocket.stream.BlockingConnection

#performs new BlockingConnection(String, int, SSLContext.getDefault(), boolean)bc = BlockingConnection.new(‘smtp.web.de‘, 25, SSLContext::default, false) 

bc.receive_timeout_millis = 60 * 1000 # performs setReceiveTimeoutMillis(long)puts bc.read_string_by_delimiter("\r\n")  # performs readStringByDelimiter(String)

bc.write("STARTTLS\r\n")  puts bc.read_string_by_delimiter("\r\n")bc.activate_secured_mode()

bc.write(‘AUTH PLAIN ‘ + ["\000" + ‘from.me‘ + "\000" + ‘myPassword‘].pack(‘m‘))puts bc.read_string_by_delimiter("\r\n")

bc.write("HELO Server\r\n")puts bc.read_string_by_delimiter("\r\n")

bc.write("MAIL FROM: [email protected]\r\n")puts bc.read_string_by_delimiter("\r\n")

bc.write("RCPT TO: [email protected]\r\n")puts bc.read_string_by_delimiter("\r\n")

bc.write("data\r\n")puts bc.read_string_by_delimiter("\r\n")

mail =‘Message-ID: 46D957AF.2020804Date: Sat, 01 Sep 2007 14:14:39 +0200From: [email protected]User-Agent: my mail clientMIME-Version: 1.0To: [email protected]Subject: what I have to sayContent-Type: text/plain; charset=ISO-8859-15; format=flowedContent-Transfer-Encoding: 7bit

combining scripting languages with Java is great‘

bc.write("#{mail}\r\n.\r\n")puts bc.read_string_by_delimiter("\r\n")

bc.write("quit\r\n")puts bc.read_string_by_delimiter("\r\n")bc.close()

package test;

public class NonBlockingConnection  {        public void write(int i)  {                System.out.println("writing int " + i);        }        public void write(long l)  {                System.out.println("writing long " + l);        }}

from java.lang import Integerfrom test import NonBlockingConnection

# call 1 NonBlockingConnection().write(214748364700) # call method based on python built-in data type# prints out:# writing long 214748364700

# call 2NonBlockingConnection().write(55)  # call method based on python built-in data type# prints out:# writing long 55# ups, not int?

# call 3NonBlockingConnection().write(Integer(55))  

# pass over a Java object instead of python data type# prints out:# writing int 55

String rubyScript = "def write(msg) \r\n" +                        "      puts msg \r\n" +                        "end \r\n" +                         "\r\n" +                        " def anotherFunction() \r\n" +                        "     # do something \r\n" +                        "end \r\n";

    ScriptEngineManager manager = new ScriptEngineManager();    ScriptEngine engine = manager.getEngineByName("jruby");

    engine.eval(rubyScript);

    Invocable inv = (Invocable) engine;    inv.invokeFunction("write", new Object[] { "hello" });    // prints out:    // hello

from test import NonBlockingConnectionfrom java.lang import Integerfrom java.lang import Long

class ExtendedNonBlockingConnection(NonBlockingConnection):    def write(self, *args):       # the signature to handle?       if len(args) == 1 and isinstance(args[0], Integer):           print ‘writing overriden int ‘ + args[0].toString()       # no, let the super method do the stuff       else:          NonBlockingConnection.write(self, *args)

ExtendedNonBlockingConnection().write(Integer(777))# prints out:# writing overridden int 777

ExtendedNonBlockingConnection().write(Long(777))# prints out:# writing long 777

import test.NonBlockingConnection

class ExtendedNonBlockingConnection extends NonBlockingConnection {    // overwrite the int method    def write(int i) {        println ‘writing overridden int ‘ + i     }}

new ExtendedNonBlockingConnection().write((int) 777)// prints out:// writing overridden int 777

new ExtendedNonBlockingConnection().write((long) 777)// prints out:// writing long 777

include Java

RandomAccessFile = java.io.RandomAccessFileDataConverter = Java::org.xsocket.DataConverter MultithreadedServer = Java::org.xsocket.stream.MultithreadedServerIConnection = Java::org.xsocket.stream.IConnectionIConnectHandler = Java::org.xsocket.stream.IConnectHandlerIDataHandler = Java::org.xsocket.stream.IDataHandler

class TestMessageSinkManager   def new_message_sink_channel()      file = java.io.File.create_temp_file(‘smtptest‘, ‘mail‘)      return RandomAccessFile.new(file, ‘rw‘).channel   endend 

class SmtpProtocolHandler   include IConnectHandler   include IDataHandler

   def initialize(domain, message_sink_manager)      @domain = domain      @msg_sink_mgr = message_sink_manager      @helo_pattern = Regexp.compile(/HELO.*/, Regexp::IGNORECASE)      @mail_from_pattern = Regexp.compile(/MAIL FROM:.*/, Regexp::IGNORECASE)      @rcpt_to_pattern = Regexp.compile(/RCPT TO:.*/, Regexp::IGNORECASE)      @data_pattern = Regexp.compile(/DATA.*/, Regexp::IGNORECASE)      @quit_pattern = Regexp.compile(/QUIT.*/, Regexp::IGNORECASE)   end

   # new incoming (non blocking) connection   def onConnect(nbc)      nbc.flushmode = IConnection::FlushMode::ASYNC      nbc.attachment = { ‘state‘ => ‘CMD‘, ‘msg_num‘ => 0 }      nbc.write("220 #{@domain} SMTP ready \r\n")      return true   end

   # data received for the (non blocking) connection   def onData(nbc)

      case nbc.attachment[‘state‘]         # message receiving mode: non-blocking streaming of the msg data          when ‘MESSAGE‘            # some validations have to be performed by the data sink            delimiter_found = nbc.read_available_by_delimiter("\r\n.\r\n", 

                nbc.attachment[‘message_channel‘])                      if delimiter_found               nbc.attachment[‘message_channel‘].close()               nbc.attachment[‘state‘] = ‘CMD‘               nbc.write("250 OK #{nbc.get_id()}.#{nbc.attachment[‘msg_num‘]} \r\n")            end

         # smtp-command mode: perform command          else            # a BufferUnderflowException will been thrown, if delimiter not found            smtp_cmd_line = nbc.read_string_by_delimiter("\r\n")

            case smtp_cmd_line               when @helo_pattern                  nbc.write("250 #{@domain} SMTP Service \r\n")

               when @mail_from_pattern                  originator = smtp_cmd_line[10,9999].strip()                  # ...here some validations should be performed (valid address, ...)                   nbc.attachment[‘originator‘] = originator                  nbc.attachment[‘recipients‘] = []                  nbc.write("250 #{@originator} is syntactically correct\r\n")

               when @rcpt_to_pattern                  rec = smtp_cmd_line[8,9999].strip()                  # ...here some validations should be performed (max recipients, ...)                  nbc.attachment[‘recipients‘] = nbc.attachment[‘recipients‘] << rec                  nbc.write("250 #{rec} verified \r\n")  

               when @data_pattern                  # ...here some validation should be performed (recipients set, ...)                  nbc.attachment[‘state‘] = ‘MESSAGE‘                  nbc.attachment[‘msg_num‘] = nbc.attachment[‘msg_num‘] + 1                  nbc.attachment[‘message_channel‘] = 

                      @msg_sink_mgr.new_message_sink_channel()                  time_stamp = "Received: FROM #{nbc.remote_address.canonical_host_name} 

                     BY #{@domain}\r\n" +                                   "id #{nbc.get_id()}.#{nbc.attachment[‘msg_num‘]}; 

                     " + Time.new.to_s() + "\r\n"  nbc.attachment[‘message_channel‘].write(DataConverter.to_byte_buffer(time_stamp,

    ‘US-ASCII‘))                                    nbc.write("354 Enter message, ending with \".\"  \r\n")

               when @quit_pattern                  nbc.write("221 SMTP service closing connection \r\n")                  nbc.close()

               else                   nbc.write("500 Unrecognized command \r\n")

            end               end      return true   endend

server = MultithreadedServer.new(25, SmtpProtocolHandler.new(‘mSrv‘, 

    TestMessageSinkManager.new))server.run()