C# 传输 XML 到 JAVA

Question

求   客户端用C#编程发送   接收端用JAVA编程处理
请问应该用哪种发送方法？？？？？？？？ 最好有代码  ········万分感谢  

Answer 1

很多种实现方法：
1、web service，java端必须有web server
2、socket,java端是服务端，使用socket accpet request，然后处理请求
3、使用中间存储，定时扫描，异步处理
4、使用现成的rpc框架，比如thrift

Answer 2

十分感谢 ~~~~~~~那这个和SOAP  有什么关系吗？？？？？？？、

Answer 3

web service是基于SOAP的。
你的服务器是什么？tomcat?jboss?

Answer 4

用http的方式post给java的servlet或jsp也是可以的

Answer 5

weblogic服务器   。但是使用JAVA写处理接收的信息的。

Answer 6

//2个参数，一个是网址，一个是参数 也就是你的xml
        public static string SendRequest(string uri, string poscontent)
        {
            string responseText = "";
            try
            {
                StreamReader reader;
//这里可以设置编码
                byte[] postBody = System.Text.Encoding.Default.GetBytes(poscontent);
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
                request.Method = "POST";
                request.ContentType = "application/x-www-form-urlencoded";
                request.ContentLength = postBody.Length;
                request.AllowWriteStreamBuffering = true;                Stream dataStream = request.GetRequestStream();
                dataStream.Write(postBody, 0, postBody.Length);
                dataStream.Close();
                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                dataStream = response.GetResponseStream();
                Encoding encode = System.Text.Encoding.GetEncoding("UTF-8");
                reader = new StreamReader(dataStream, encode);                responseText = reader.ReadToEnd();
                reader.Close();
                dataStream.Close();
                response.Close();
            }
            catch(Exception e)
            {
                Logger.writeln("从服务器获取数据失败");
            }
            return responseText;
        }

Answer 7

kangkx：
这样发送XML到服务器了   服务器接受了能进行处理不？？，
                        客户端能接收到处理后的XML不？？？
              还用不用在 request里加用的是哪个处理啊？？？？？？？？
感谢！！！！！！

Answer 8

weblogic 没写过 呵呵 tomcat的倒是有个

Answer 9

上面方法返回的 responseText 就是java返回的xml内容，后续处理可以写在别的方法里。
C#端和java端都是你来写么？我只知道C#可以这样。java端的处理不会。

Answer 10

c#和Java都用的socket 呵呵 

Answer 11

kangkx：
 我只写C#端。。

Answer 12

luoSaiMingJavaAndC：
好的 谢谢

Answer 13

我的思路：通过URL传递一个xml的字符串
在JAVA中对该字符串进行解析，生成一个新的xml

Answer 14

using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.IO;
using System.Windows.Forms;namespace webDal2
{
    public class UploadFile
    {
        
        #region ±äÁ¿
        private Socket socket = null;        private IPEndPoint ipEnd = null;        ChangeLetter changLetter = new ChangeLetter();        /// <summary>
        /// ·¢ËÍÃüÁî
        /// </summary>
        SendCommand sendCommand = new SendCommand();        private Encoding encodingGB = Encoding.GetEncoding("GB2312");        //public const int PACKET_SIZE = int.MaxValue;               // ¶¨ÒåÎļþ·Ö°ü¡£°üµÄ´óС
        public  int PACKET_SIZE = 512;               // ¶¨ÒåÎļþ·Ö°ü¡£°üµÄ´óС        //public const int PACKET_GROUP_COUNT = 256;        
        //public const int PACKET_CONTENT = 512;
        public const int PACKET_COUNT = 256;              // °üµÄÊýÁ¿       -- ×î´ó´«Êä´óС 256*256*512byte  32M        private byte[] byRec = new byte[128];        private int nLastPackSize = 0;                    // ×îºóÒ»¸ö°üµÄ´óС  v2        string strStart = System.Windows.Forms.Application.StartupPath 
            + "\\systemXml";  //ÉÏ´«ÎļþµÄ·¾¶
        string strStart2 = "C:\\report";  //ÉÏ´«ÎļþµÄ·¾¶
        #endregion         public void uploadFileToServer(Socket socket,string  fileName)
        {
            this.socket = socket;
            //¸æËß·þÎñÆ÷ ÒªÉÏ´«Îļþ
            byte[] upLoadFile = Encoding.ASCII.GetBytes("UploadFile\r\n");
            SocketSendMessage(this.socket, upLoadFile);            //SendOneFile(this.socket, "D:\\text\\20091128164512421.xml");
        }        #region »ñµÃÎļþµÄ³¤¶È ÔÚÉÏ´«µÄʱºò ÊǸöѹËõÎļþ 
        public void setToServerFileLength(Socket socke, string strFile)
        {
            FileStream fs = new FileStream(strStart2 + "\\" + strFile, FileMode.Open, FileAccess.Read);            long lFile = fs.Length;        //Îļþ³¤¶È            PACKET_SIZE =(int) lFile;            sendCommand.sendStr("(clientFileLength)" + Convert.ToString(lFile) + "," + strFile); //·¢ËÍÎļþµÄ³¤¶È 
            //¸æËß³¤¶ÈºóÔÙ·¢ËÍÎļþ 
            SendOneFile(socke, fs, strStart2 + "\\" + strFile);        }
        #endregion         #region ·¢ËÍÎļþ
        private void SendOneFile(Socket socket, FileStream fs, string strFile)
        {
            Socket socketFile = socket;                      long lFile = fs.Length;        //Îļþ³¤¶È            #region ÔÚÒÔÇ°µÄ»ù´¡ÉϸĵÄÄÜ´«Êä32M            // ¼ÆËã·Ö°üÇé¿ö
            byte[] byPack = CalcPackCount(lFile);            #endregion            // ÎļþÃû
            string[] strPath = strFile.Split('\\');
            string strFileName = strPath[strPath.Length - 1].ToString();            SendFileStream(socket, fs, byPack, strFileName);
        }
        #endregion         #region ¾ßÌåµÄ·¢ËÍ
        private void SendFileStream(Socket socketStream, FileStream fs, byte[] byPack, string strFileName)
        {
            byte[] byHead = new byte[256];
            byHead[0] = byPack[0];
            byHead[1] = byPack[1];            byte[] byFileName = encodingGB.GetBytes(strFileName);
            byHead[2] = Convert.ToByte(byFileName.Length);
            byFileName.CopyTo(byHead, 3);            byte[] newbyHead = new byte[3 + byFileName.Length];
            for (int i = 0; i < newbyHead.Length; i++)
            {
                newbyHead[i] = byHead[i];
            }
            //°ÑÕâ¸ö byhead ½øÐÐת»» 
            //string str = Encoding.UTF8.GetString(byHead);
            string str = Encoding.UTF8.GetString(newbyHead);
            str = ChangeLetter.StringToUnicode(str) + "\r\n";
            str = "(UploadFile)"  + str ;
            byHead = Encoding.ASCII.GetBytes(str);            //·¢Ë͸ø·þÎñÆ÷ ÓжàÉÙ¸ö°ü
            SocketSendMessage(socketStream, byHead);            byte[] byBody = new byte[PACKET_SIZE];             // °üÌå            int nPackCount = Convert.ToInt32(byPack[0]) * Convert.ToInt32(byPack[1]);    // ¶àÉÙ¸ö°ü            int nCurrentPack = 0;            while (true)
            {
                if (socketStream != null)
                {
                    SocketReceiveMessage(socketStream);
                }                // ·þÎñÆ÷¶Ë·¢ËÍÀ´µÄ½ÓÊÕÍê³ÉµÄ±êʾ
                if (Convert.ToChar(byRec[0]) == 'E')
                {
                    fs.Dispose();
                    fs.Close();
                    break;
                }
                else if (Convert.ToChar(byRec[0]) == 'S')
                {
                    nCurrentPack = Convert.ToInt32(byRec[1]) * 256 + Convert.ToInt32(byRec[2]);                    fs.Seek((nCurrentPack - 1) * PACKET_SIZE, SeekOrigin.Begin);                    byBody = new byte[PACKET_SIZE];                    if ((nCurrentPack == nPackCount) && (nLastPackSize != 0))
                    {
                        fs.Read(byBody, 0, nLastPackSize);
                    }
                    else
                    {
                        fs.Read(byBody, 0, PACKET_SIZE);
                    }                    //°ÑÕâ¸ö byBody ½øÐÐת»»  °ÑÀïÃæµÄÊý×Öת³É Unicode
                    //str = Encoding.UTF8.GetString(byBody);
                    //str = ChangeLetter.StringToUnicode(str) + "\r\n";
                    //byBody = Encoding.ASCII.GetBytes(str);
                    string allStr = changLetter.formAscToString(byBody)+"\r\n";
                    byBody = System.Text.Encoding.ASCII.GetBytes(allStr);  
                   // byBody = changLetter.formAscToUnicode(byBody);                    if (socketStream != null)
                    {
                        SocketSendMessage(socketStream, byBody);
                    }
                    else
                    {
                        Console.WriteLine("ÎļþÉÏ´«½áÊø");
                        return;
                    }
                }
            }
        }
        #endregion         #region Socket ½ÓÊÕÎļþ±êÖ¾
        /// <summary>
        /// Socket ½ÓÊÕÎļþ±êÖ¾ 
        /// </summary>
        /// <param name="socketRec"></param>
        /// <returns></returns>
        private void SocketReceiveMessage(Socket socketRec)
        {
            try
            {
                byRec = new byte[128];
                int bytesRec = socketRec.Receive(byRec);
                string result = Encoding.ASCII.GetString(byRec, 0, bytesRec);
                result=result.Replace("\r", "");
                result=result.Replace("\n", "");
                result = ChangeLetter.UnicodeToString2(result);
                byRec = System.Text.Encoding.ASCII.GetBytes(result);
            }
            catch
            {
                socketRec = null;
            }
        }
        #endregion        #region  Socket ·¢ËÍÐÅÏ¢
        /// <summary>
        /// Socket ·¢ËÍÐÅÏ¢
        /// </summary>
        /// <param name="socketSend"></param>
        /// <param name="bySend"></param>
        private void SocketSendMessage(Socket socketSend, byte[] bySend)
        {            try
            {
                socketSend.Send(bySend);
            }
            catch
            {
                if (socketSend != null)
                {
                    socketSend.Close();
                }                socketSend = null;
            }
        }
        #endregion         #region ¼ÆËã·Ö°üÇé¿ö
        private byte[] CalcPackCount(long lFile)
        {
            byte[] byRet = new byte[2];            int nFirstPack = 0;
            int nSecondPack = 0;
            long lTmp = 0;            // ÁÙʱ            nLastPackSize = 0;            nFirstPack = Convert.ToInt32(lFile / (256 * PACKET_SIZE));            lTmp = lFile % (256 * PACKET_SIZE);            nSecondPack = Convert.ToInt32(lTmp / PACKET_SIZE);            nLastPackSize = Convert.ToInt32(lTmp % PACKET_SIZE);            // ×îºóÒ»¸ö°üÖдóС´óÓÚ0£¬£¬¸ø°üÊý¼Ó1
            if (nLastPackSize > 0)
            {
                nSecondPack++;
            }            // µÚ¶þ¸ö°üÄڵİüÊý´óÓÚ256 ¾Í¸øµÚÒ»¸ö°üÄڵİüÊý¼Ó1
            if (nSecondPack >= 256)
            {
                nFirstPack++;
                nSecondPack -= 256;
            }            byRet[0] = Convert.ToByte(nFirstPack);
            byRet[1] = Convert.ToByte(nSecondPack);
            //byRet[0] = Convert.ToByte(0);
            //byRet[1] = Convert.ToByte(1);
            return byRet;        }
        #endregion 
    }
}

Answer 15

using System;
using System.Collections.Generic;
using System.Text;
using System.Globalization;namespace webDal2
{
    public class ChangeLetter
    {
        public static string StringToUnicode(string srcText)
        {
            string dst = "";
            char[] src = srcText.ToCharArray();
            for (int i = 0; i < src.Length; i++)
            {
                byte[] bytes = Encoding.Unicode.GetBytes(src[i].ToString());
                string str = @"\u" + bytes[1].ToString("X2") + bytes[0].ToString("X2");
                dst += str;
            }
            return dst;
        }        /// <summary>
        /// ½«Unicode×Ö´®\u....\u....¸ñʽ×Ö´®×ª»»ÎªÔ­Ê¼×Ö·û´®
        /// </summary>
        /// <param name="srcText"></param>
        /// <returns></returns>
        public static string UnicodeToString(string srcText)
        {
            string dst = "";
            Console.WriteLine(srcText);
            if (srcText.Length > 0)
            {
                //°Ñ×îºóËĸö×Ö·û È¥µô  \r\n
                srcText = srcText.Substring(0, srcText.Length - 2);
                string src = srcText;
                int len = srcText.Length / 6;                for (int i = 0; i <= len - 1; i++)
                {
                    string str = "";
                    str = src.Substring(0, 6).Substring(2);
                    src = src.Substring(6);
                    byte[] bytes = new byte[2];
                    bytes[1] = byte.Parse(int.Parse(str.Substring(0, 2), NumberStyles.HexNumber).ToString());
                    bytes[0] = byte.Parse(int.Parse(str.Substring(2, 2), NumberStyles.HexNumber).ToString());
                    dst += Encoding.Unicode.GetString(bytes);
                }
            }
            return dst;
        }        /// <summary>
        /// ºóÃæûÓР »»ÐбêÖ¾µÄ
        /// </summary>
        /// <param name="srcText"></param>
        /// <returns></returns>
        public static string UnicodeToString2(string srcText)
        {
            //°Ñ×îºóËĸö×Ö·û È¥µô  \r\n
            //srcText = srcText.Substring(0, srcText.Length - 2);
            string dst = "";
            string src = srcText;
            int len = srcText.Length / 6;            for (int i = 0; i <= len - 1; i++)
            {
                string str = "";
                str = src.Substring(0, 6).Substring(2);
                src = src.Substring(6);
                byte[] bytes = new byte[2];
                bytes[1] = byte.Parse(int.Parse(str.Substring(0, 2), NumberStyles.HexNumber).ToString());
                bytes[0] = byte.Parse(int.Parse(str.Substring(2, 2), NumberStyles.HexNumber).ToString());
                dst += Encoding.Unicode.GetString(bytes);
            }
            return dst;
        }
        /// <summary>
        /// ´«Èë stirngÊý×é 
        /// ·µ»Ø byteÊý×é
        /// </summary>
        /// <param name="str"></param>
        public static string[] UnicodeToString3(string[] str)
        {
            string[] byte1 = new string[str.Length];
            for (int i = 0; i < str.Length; i++)
            {
                string ri = str[i];
                string result = UnicodeToString2(ri);
                byte1[i] = result;
            }
            return byte1;
        }        public static byte[] UnicodeToString4(string[] str)
        {
            UnicodeToString3(str);
            byte[] byte1 = new byte[str.Length];
            for (int i = 0; i < str.Length; i++)
            {
                string ri = str[i];
                string result = UnicodeToString2(ri);
                if ("\r\n".Equals(result) || "".Equals(result))
                {
                    continue;
                }
                try
                {
                    int inti = Convert.ToInt32(result);
                    byte bb2 = (byte)inti;
                    //byte bb = Convert.ToByte(result);
                    byte1[i] = bb2;
                }
                catch
                {
                    continue;
                }
            }
            return byte1;
        }
        /// <summary>
        /// °ÑbyteÊý×éת³ÉUnicode
        /// </summary>
        /// <param name="ascii"></param>
        /// <returns></returns>
        public byte[] formAscToUnicode(byte [] ascii)
        {
            byte[] allByte = new byte[ascii.Length * 18];
            int allCount = 0;
            for (int i = 0; i < ascii.Length; i++)
            {
                byte onebyte = ascii[i];                string strOneByte = Convert.ToString(onebyte);                strOneByte = StringToUnicode(strOneByte);                byte[] littleByte = System.Text.Encoding.ASCII.GetBytes(strOneByte);                for (int k = 0; k < littleByte.Length; k++)
                {
                    allByte[allCount] = littleByte[k];
                    allCount++;
                }
            }
            return allByte;
        }        public string formAscToString(byte[] ascii)
        {
            string allString = "";
            int allCount = 0;
            for (int i = 0; i < ascii.Length; i++)
            {
                byte onebyte = ascii[i];
                string strOneByte = Convert.ToString(onebyte);
                if (i == ascii.Length - 1)
                {
                    strOneByte = StringToUnicode(strOneByte);
                }
                else
                {
                    strOneByte = StringToUnicode(strOneByte) + ",";
                }
                allString += strOneByte;
            }
            return allString;  
        }
    }
}和Java的通讯要有编码的转换