1、以消息中间件为基础的数据集成平台。企业应用集成（EAI）是企业软件发展的必经阶段，一直以来很多公司都在以原始的、分散的、偶然的方式做着业务系统之间的集成工作，随着企业应用数量的增加、技术的多样化和复杂化，加之EAI理念不断深化和EAI产品的大力推广，大中型企业必将采取一种先进的、全面的、持续不断站在整个公司战略和流程层面考虑的应用整合平台。数据集成做为EAI的第一层和基础层是进行应用整合必不可少的工作。

2、以Ajax＋SOA构建的新型业务系统。系统后台采用SOA理念对业务系统的功能和流程进行抽象，形成不同层次能完成特定任务的标准服务提供出来。前台展现层采用Ajax技术直接调用、访问后台的服务，使B/S结构重新回归到类似于Delphi、PB时代的三层C/S结构。（后台借用SOA的思想来抽象出服务，但从性能的角度考虑，不一定采用SOAP和Web Service的标准协议做为前后台的传输协议）

3、以开源Portal服务器和Portlet技术为主线的用户界面集成。单一入口、通用外观、单点登陆、个性化定制、公共安全服务外加一个内容管理系统，这些特性对于企业用户来说还是很有吸引力，使得Portal本身具有良好的市场前景，而且对于企业或者政府领导来说这些都是实实在在看得见的业绩，跟一味鼓吹后台应用整合，架构调整（SOA）相比，用Portal做为切入点，再进行应用整合是一种很好的方式。

4、动态语言和敏捷开发。以Ruby on Rails和Django为代表的敏捷开发框架以及随之而来的极限编程理念必将引起整个软件行业的一次变革，并且这场变革现在已经初露端倪，如何把握这一契机，迎接变革，抓住机会，抢占新的市场是摆在每个软件公司面前的问题。动态语言和敏捷开发最大的好处在于大大的缩短软件开发周期和降低需求变更对项目造成的影响，让软件开发者能够根据客户的要求“随需而变”，但就现阶段来说要普及和推广还有比较大的难度，在开发工具、协作方式、服务支持上还有一些问题，如何与传统软件工程相结合，如何适应企业应用的要求都是需要探索的。目前，我们要保持一定的技术能力，在小型业务系统进行积极实践和创新，引导客户，不断积累，一旦市场成熟就能够全面出击。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

顾问的首要工作：满足客户的求知欲

如果你花了高价钱请了个家庭厨师，当然他要能烧出合你口味的菜，但是如果他不能解答你关于烧菜的各种古怪的问题，满足你关于其他口味菜肴的好奇心，那么你一样会怀疑高价花的是否值。

所有人都知道答案，但没有人知道问题

顾问通过合适的方法找到问题，答案往往是客户自己想出来的。

如果你不能让客户信任你，那么项目就失败了

只有相信你才会相信你的成果，而让客户产生信任感的往往不是你的专业知识。顾问的交付品是文档和Presentation，信就一字千金，不信就一文不值。

你想到的客户未必没想到，关键是怎么表达

形式比内容重要，表达比想法重要，在靠嘴为生的行业这是条铁律。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师

public static void main(String argv[])
    {
        int port = 0;
        String serviceName = null;
        //处理在启动脚本中传入的几个参数
        for(int i = 0; i < argv.length; i++)
        {
            if(argv[i].equals("-port") && i < argv.length - 1)
                port = Integer.valueOf(argv[1 + i++]).intValue();
            if(argv[i].equals("-home") && i < argv.length - 1)
                Config.setProperty("watt.server.homeDir", argv[1 + i++]);
            if(argv[i].equals("-service") && i < argv.length - 1)
                serviceName = argv[1 + i++];
        }
        
        if(port != 0)
            Config.setProperty("watt.server.port", Integer.toString(port));
        UniqueApp ua = null;
        int uaport = 4321;
        //获得一个叫uaport的端口参数，默认是4321
　　  String uapstr = System.getProperty("watt.server.uaport");
        if(uapstr != null)
            try
            {
                uaport = Integer.parseInt(uapstr);
            }
            catch(NumberFormatException _ex) { }

        //用这个uaport创建一个app
        ua = new UniqueApp(uaport);
        try
        {
            ua.start();
            //调用Server这个类的start方法初始化IS
            Server.start(argv);
            ua.quit();
            if(Server.restart())
            {
                try
                {
                    if(serviceName != null)
                    {
                        String homepath = System.getProperty("watt.server.homeDir", ".");
                        String cmd = homepath + File.separator + "bin" + File.separator + "RestartService.exe " + serviceName;
                        Runtime.getRuntime().exec(cmd);
                    }
                }
                catch(Exception e)
                {
                    e.printStackTrace();
                }
                System.exit(42);
            } else
            {
                System.exit(0);
            }
        }
        catch(com.wm.util.UniqueApp.DeniedException _ex)
        {
            System.out.println("Server cannot execute. A server with this configuration is already running.");
            System.exit(0);
        }
    }

public void start()
        throws DeniedException
    {
        if(port_ > lastPort_)
            debugPrint("UNQ  ERROR: port_ (" + port_ + ") > lastPort_ (" + lastPort_ + ")");
        for(; port_ <= lastPort_; port_++)
        {
            debugPrint("UNQ  attempting connection on port " + port_);
            try
            {
                debugPrint("UNQ  " + iden_ + " sending initial message");
                String response = send("init");
                debugPrint("UNQ  " + iden_ + " got response " + response);
                if(response == null)
                {
                    debugPrint("UNQ  connected on port " + port_ + ", but no response");
                    continue;
                }
                if(response.equals("DENIED"))
                    throw new DeniedException();
                if(response.equals("OK"))
                {
                    runHeartbeat();
                    break;
                }
                debugPrint("UNQ  connected on port " + port_ + ", but incomprehensible response");
                continue;
            }
            catch(IOException ioe)
            {
                if(DEBUG)
                    ioe.printStackTrace(System.out);
                runRegistry();
            }
            break;
        }

    }

public String send(String type)
        throws IOException
    {
        Socket socket = new Socket("localhost", port_);
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
        String msg = type + ": " + iden_;
        out.println(msg);
        out.flush();
        return in.readLine();
    }

public void runRegistry()
    {
        debugPrint("UNQ  " + iden_ + " starting registry on port " + port_);
        registry_ = new AppRegistry(iden_, port_);
    }

public AppRegistry(String iden, int port)
    {
        info_ = new HashMap();
        out_ = null;
        socket_ = null;
        info_.put(iden, new Long(0x7fffffffffffffffL));
        port_ = port;
        Thread t = new Thread(this);
        t.setDaemon(true);
        t.start();
    }

public void run()
    {
        debugPrint("REG  running");
        openSocket();
        if(socket_ == null)
            debugPrint("REG  no socket");
        else
            while(socket_ != null) 
                processConnection();
        debugPrint("REG  stopped");
    }

protected void openSocket()
    {
        try
        {
            debugPrint("REG  running socket server on port " + port_);
            socket_ = new ServerSocket(port_);
            socket_.setSoTimeout(3000);
        }
        catch(IOException ioe)
        {
            if(DEBUG)
                ioe.printStackTrace(System.out);
            debugPrint("REG  failed to open socket");
            socket_ = null;
        }
    }

protected void processLineReceived(String line)
    {
        debugPrint("REG  processLineReceived(" + line + ")");
        int pos = line != null ? line.indexOf(": ") : -1;
        if(pos != -1)
        {
            String type = line.substring(0, pos);
            String identifier = line.substring(pos + 2);
            if(type.equals("init"))
                handleInit(identifier);
            else
            if(type.equals("update"))
                update(identifier);
            else
            if(type.equals("quit"))
                quit(identifier);
            else
                debugPrint("REG  unknown type: '" + type + "' in line: '" + line + "'");
        }
    }

public static void start(String args[])
    {
        gServer = new Server(args);
        gServer.start();
        try
        {
            gServer.join();
        }
        catch(Exception _ex) { }
    }

public void run()
    {
        try
        {
            long start = System.currentTimeMillis();
            com.wm.util.Config.setProperty("watt.server", "true");
            gRestart = false;
            gInShutdown = false;
            gListeners = new Values();
            gResources = new Resources(System.getProperty("watt.server.homeDir", "."), true);
            gConfFile = gResources.getConfigFile("server.cnf");
            gResources.getLogJobsInDir();
            gResources.getLogJobsOutDir();
            gResources.getDatastoreDir();
            loadConfiguration();
            Scheduler.init();
            String tmp = com.wm.util.Config.getProperty("false", "watt.server.control.runMemorySensor");
            if(Boolean.valueOf(tmp).booleanValue())
                MemorySensor.init(ServerController.getInstance());
            ThreadPoolSensor.init(ServerController.getInstance());
            checkProperties();
            com.wm.util.Config.processCmdLine(args);
            setupLogging();
            JournalLog.init(args);
            JournalLogger.init(JournalLog.newProducer(), JournalLog.getHandler());
            JournalLogger.logCritical(1, 25, Build.getVersion(), Build.getBuild());
            if(!LicenseManager.init())
            {
                JournalLogger.logCritical(1, 14);
                return;
            }
            RepositoryManager.init();
            JDBCConnectionManager.init();
            AuditLogManager.init();
            setupIPRules();
            UserManager.init();
            ACLManager.init();
            ThreadManager.init();
            StateManager.init();
            ListenerAdmin.init();
            ServiceManager.init();
            InvokeManager.init();
            Statistics.init();
            NetURLConnection.init();
            ContentManager.init();
            CacheManager.init();
            EventManager.init();
            boolean dispatcherCorrectlyInit = false;
            try
            {
                DispatchFacade.init();
                dispatcherCorrectlyInit = true;
            }
            catch(Exception e)
            {
                JournalLogger.logCritical(31, 25, e);
            }
            WebContainer.init();
            ISMonEvtMgr.create();
            PackageManager.init();
            DependencyManager dm = NSDependencyManager.current();
            if(dm == null || !dm.isEnabled())
                JournalLogger.logDebugPlus(3, 15, 25);
            else
                JournalLogger.logDebugPlus(3, 14, 25);
            try
            {
                if(dispatcherCorrectlyInit)
                    DispatchFacade.start();
            }
            catch(Exception ce)
            {
                JournalLogger.logError(35, 25, ce);
            }
            PortManager.init();
            MimeTypes.init();
            HTTPDispatch.init();
            ProxyHTTPDispatch.init();
            LBHTTPDispatch.init();
            CacheManager.startSweeper();
            Document.setHostServices(new ServerXmlHostServices());
            try
            {
                ClusterManager.init();
            }
            catch(Exception e)
            {
                JournalLogger.logDebug(103, 33, e.getMessage());
            }
            try
            {
                String jobDir = com.wm.util.Config.getProperty("logs/jobsout", "watt.tx.jobdir");
                TContext.init(jobDir);
            }
            catch(ServiceException e)
            {
                JournalLogger.logDebugPlus(3, 9998, 36, e);
            }
            if(Config.isSSLPresent())
                try
                {
                    Class c = Class.forName("com.wm.app.b2b.server.ServerTrustDeciderManager");
                    TrustDeciderManager tdm = (TrustDeciderManager)c.newInstance();
                    TrustManager.setManager(tdm);
                }
                catch(Throwable _ex) { }
            if(!ListenerAdmin.isReady() && !gCanListen)
            {
                JournalLogger.logCritical(4, 14);
                return;
            }
            Scheduler.scheduleTask("Key Update", new KeyUpdate(), 0L, 0x5265c00L);
            String sc = com.wm.util.Config.getProperty("true", "watt.server.saveConfigFiles");
            if((new Boolean(sc)).booleanValue())
                saveConfigFiles();
            if(Configurator.isBrokerConfigured())
                SyncManager.init();
            gRunning = true;
            long startTimeSeconds = (System.currentTimeMillis() - start) / 1000L;
            JournalLogger.logCritical(2, 14, Long.toString(startTimeSeconds));
            synchronized(this)
            {
                try
                {
                    wait();
                }
                catch(Exception e)
                {
                    e.printStackTrace();
                }
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        JournalLog.unInit();
    }

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师

if(configurationOptionStr == null) {  
  url = Loader.getResource(DEFAULT_XML_CONFIGURATION_FILE);
  if(url == null) {
    url = Loader.getResource(DEFAULT_CONFIGURATION_FILE);
  }
      } else {
  try {
    url = new URL(configurationOptionStr);
  } catch (MalformedURLException ex) {
    // so, resource is not a URL:
    // attempt to get the resource from the class path
    url = Loader.getResource(configurationOptionStr); 
  }  
}

static public URL getResource(String resource) {
    ClassLoader classLoader = null;
    URL url = null;
    
    try {
    if(!java1) {
      classLoader = getTCL();
      if(classLoader != null) {
        LogLog.debug("Trying to find ["+resource+"] using context classloader "
         +classLoader+".");
        url = classLoader.getResource(resource);      
        if(url != null) {
          return url;
        }
      }
    }
    
    // We could not find resource. Ler us now try with the
    // classloader that loaded this class.
    classLoader = Loader.class.getClassLoader(); 
    if(classLoader != null) {
      LogLog.debug("Trying to find ["+resource+"] using "+classLoader
             +" class loader.");
      url = classLoader.getResource(resource);
      if(url != null) {
        return url;
      }
    }
    } catch(Throwable t) {
    LogLog.warn(TSTR, t);
    }
    
    // Last ditch attempt: get the resource from the class path. It
    // may be the case that clazz was loaded by the Extentsion class
    // loader which the parent of the system class loader. Hence the
    // code below.
    LogLog.debug("Trying to find ["+resource+
         "] using ClassLoader.getSystemResource().");
    return ClassLoader.getSystemResource(resource);
  } 

public InputStream getResourceAsStream(String name)
    {
        for(int i = 0; i < resdirs.size(); i++)
        {
            File rfile = new File((File)resdirs.elementAt(i), name);
            if(rfile.exists())
                try
                {
                    return new FileInputStream(rfile);
                }
                catch(IOException _ex)
                {
                    JournalLogger.log(27, 28, name);
                }
        }

        for(int i = 0; i < jars.size(); i++)
            try
            {
                ZipFile zfile = new ZipFile((File)jars.elementAt(i));
                ZipEntry ze = zfile.getEntry(name);
                if(ze != null)
                {
                    InputStream is = null;
                    is = zfile.getInputStream(ze);
                    return is;
                }
            }
            catch(Exception _ex)
            {
                JournalLogger.log(26, 28, name);
            }

        for(int i = 0; i < cldirs.size(); i++)
        {
            File cfile = new File((File)cldirs.elementAt(i), name);
            if(cfile.exists())
                try
                {
                    return new FileInputStream(cfile);
                }
                catch(IOException _ex)
                {
                    JournalLogger.log(27, 28, name);
                }
        }

        return null;
    }

public static void addPackage(String pkgName)
        throws IOException, ZipException
    {
        Resources res = Server.getResources();
        ServerClassLoader scl = new ServerClassLoader(pkgName);
        scl.addJar(new File(res.getPackageCodeDir(pkgName), "classes.zip"));
        scl.addJarDir(res.getPackageJarsDir(pkgName));
        scl.addClassDir(res.getPackageClassDir(pkgName));
        scl.addResourceDir(res.getPackageResourceDir(pkgName));
        scl.addResourceDir(res.getDeprecatedPackageResourceDir(pkgName));
        pkgs.put(pkgName, scl);
    }

private void addResourceDir(File dir)
    {
        if(dir != null || dir.isDirectory())
            resdirs.addElement(dir);
    }

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师