Java 类javax.websocket.EncodeException 实例源码

public String encode(UserVisitBean userDiagramData) throws EncodeException {
    StringWriter writer = new StringWriter();
    //Makes use of the JSON Streaming API to build the JSON string.
    Json.createGenerator(writer)
            .writeStartObject()
            .write("time", String.valueOf(userDiagramData.getTime()))
            .write("totalFlow", userDiagramData.getTotalFlow())
            .write("checkInFlow", userDiagramData.getCheckInFlow())
            .write("checkInRatio", userDiagramData.getCheckInRate())
            .write("deepVisitRatio", userDiagramData.getDeepVisitRate())
            .write("jumpRatio", userDiagramData.getShallowVisitRate())
            .writeEnd()
            .flush();
    //System.out.println(writer.toString());
    return writer.toString();
}

protected final void processResult(Object result) {
    if (result == null) {
        return;
    }

    RemoteEndpoint.Basic remoteEndpoint = session.getBasicRemote();
    try {
        if (result instanceof String) {
            remoteEndpoint.sendText((String) result);
        } else if (result instanceof ByteBuffer) {
            remoteEndpoint.sendBinary((ByteBuffer) result);
        } else if (result instanceof byte[]) {
            remoteEndpoint.sendBinary(ByteBuffer.wrap((byte[]) result));
        } else {
            remoteEndpoint.sendObject(result);
        }
    } catch (IOException ioe) {
        throw new IllegalStateException(ioe);
    } catch (EncodeException ee) {
        throw new IllegalStateException(ee);
    }
}

private void handleSendFailureWithEncode(Throwable t) throws IOException, EncodeException {
    // First, unwrap any execution exception
    if (t instanceof ExecutionException) {
        t = t.getCause();
    }

    // Close the session
    wsSession.doClose(new CloseReason(CloseCodes.GOING_AWAY, t.getMessage()),
            new CloseReason(CloseCodes.CLOSED_ABNORMALLY, t.getMessage()));

    // Rethrow the exception
    if (t instanceof EncodeException) {
        throw (EncodeException) t;
    }
    if (t instanceof IOException) {
        throw (IOException) t;
    }
    throw new IOException(t);
}

protected final void processResult(Object result) {
    if (result == null) {
        return;
    }

    RemoteEndpoint.Basic remoteEndpoint = session.getBasicRemote();
    try {
        if (result instanceof String) {
            remoteEndpoint.sendText((String) result);
        } else if (result instanceof ByteBuffer) {
            remoteEndpoint.sendBinary((ByteBuffer) result);
        } else if (result instanceof byte[]) {
            remoteEndpoint.sendBinary(ByteBuffer.wrap((byte[]) result));
        } else {
            remoteEndpoint.sendObject(result);
        }
    } catch (IOException ioe) {
        throw new IllegalStateException(ioe);
    } catch (EncodeException ee) {
        throw new IllegalStateException(ee);
    }
}

private void handleSendFailureWithEncode(Throwable t) throws IOException, EncodeException {
    // First, unwrap any execution exception
    if (t instanceof ExecutionException) {
        t = t.getCause();
    }

    // Close the session
    wsSession.doClose(new CloseReason(CloseCodes.GOING_AWAY, t.getMessage()),
            new CloseReason(CloseCodes.CLOSED_ABNORMALLY, t.getMessage()));

    // Rethrow the exception
    if (t instanceof EncodeException) {
        throw (EncodeException) t;
    }
    if (t instanceof IOException) {
        throw (IOException) t;
    }
    throw new IOException(t);
}

protected final void processResult(Object result) {
    if (result == null) {
        return;
    }

    RemoteEndpoint.Basic remoteEndpoint = session.getBasicRemote();
    try {
        if (result instanceof String) {
            remoteEndpoint.sendText((String) result);
        } else if (result instanceof ByteBuffer) {
            remoteEndpoint.sendBinary((ByteBuffer) result);
        } else if (result instanceof byte[]) {
            remoteEndpoint.sendBinary(ByteBuffer.wrap((byte[]) result));
        } else {
            remoteEndpoint.sendObject(result);
        }
    } catch (IOException ioe) {
        throw new IllegalStateException(ioe);
    } catch (EncodeException ee) {
        throw new IllegalStateException(ee);
    }
}

private void handleSendFailureWithEncode(Throwable t) throws IOException, EncodeException {
    // First, unwrap any execution exception
    if (t instanceof ExecutionException) {
        t = t.getCause();
    }

    // Close the session
    wsSession.doClose(new CloseReason(CloseCodes.GOING_AWAY, t.getMessage()),
            new CloseReason(CloseCodes.CLOSED_ABNORMALLY, t.getMessage()));

    // Rethrow the exception
    if (t instanceof EncodeException) {
        throw (EncodeException) t;
    }
    if (t instanceof IOException) {
        throw (IOException) t;
    }
    throw new IOException(t);
}

public void connect(long timeout, TimeUnit unit) throws DeploymentException, IOException, EncodeException, InterruptedException, ExecutionException, TimeoutException {
    if (getState() != State.DISCONNECTED) {
        throw new IllegalStateException("Connection open, or in progress!");
    }
    this.session = ContainerProvider.getWebSocketContainer().connectToServer(this, this.uri);
    this.state = State.CONNECTING;
    final Frame connectFrame = Frame.connect(this.uri.getHost(), "1.2").heartbeat(5_000, 5_000).build();
    sendToClient(connectFrame);
    this.connectFuture = new CompletableFuture<>();
    final Frame connectedFrame = this.connectFuture.get(timeout, unit);
    this.connectFuture = null;

    final long readDelay = Math.max(connectedFrame.heartBeat().get().x, connectFrame.heartBeat().get().y);
    final long writeDelay = Math.max(connectFrame.heartBeat().get().x, connectedFrame.heartBeat().get().y);
    this.heartBeatMonitor.start(readDelay, writeDelay);
}

/**
 * 
 * @param msg
 */
public void fromBroker(@Observes @FromBroker Message msg) {
    final String sessionId = msg.sessionId();
    final Frame frame = msg.frame();
    this.log.debug("Sending message to client. [sessionId={},command={}]",
            sessionId, frame.command() != null ? frame.command() : "HEARTBEAT");

    Optional<Session> session = getSession(sessionId);

    if (!session.isPresent()) { // Java 9 has #ifPresentOrElse(...)
        this.log.error("Unable to find session! [{}]", sessionId);
    }
    getSession(sessionId).ifPresent(s -> {
        try {
            s.getBasicRemote().sendObject(frame);
        } catch (IOException | EncodeException e) {
            this.log.error("Unable to send message! [sessionid={},command={}]", sessionId, frame.command(), e);
        }
    });
}

@Test
public void onError() throws IOException, EncodeException {
    final Session session = mock(Session.class);
    when(session.getId()).thenReturn("sessionId");
    final Throwable cause = new Throwable();
    when(this.errorEvent.select(OnError.Literal.onError())).thenReturn(this.errorEvent);
    final Basic basic = mock(Basic.class);
    when(session.getBasicRemote()).thenReturn(basic);

    this.endpoint.onError(session, cause);

    verify(session).getId();
    verify(session).getUserPrincipal();
    verify(this.log).warn(eq("WebSocket error. [id={},principle={},errorId={}]"), eq("sessionId"), isNull(), anyString(), eq(cause));
    verify(this.errorEvent).select(OnError.Literal.onError());
    verify(this.errorEvent).fire(cause);
    verify(session).getBasicRemote();
    verify(basic).sendObject(any(Frame.class));
    verify(session).close(any(CloseReason.class));
    verifyNoMoreInteractions(session, basic);
}

@Test
public void fromBroker() throws IOException, EncodeException {
    final Message msg = mock(Message.class);
    when(msg.sessionId()).thenReturn("sessionId");
    final Frame frame = mock(Frame.class);
    when(msg.frame()).thenReturn(frame);
    when(frame.command()).thenReturn(Command.MESSAGE);
    final Session session = Mockito.mock(Session.class);
    getSessionMap().put("sessionId", session);
    getPrincipalSessionMap().put(NULL_PRINCIPLE, new HashSet<>(singleton(session)));
    final Basic basic = mock(Basic.class);
    when(session.getBasicRemote()).thenReturn(basic);

    this.registry.fromBroker(msg);

    verify(msg).sessionId();
    verify(msg).frame();
    verify(frame, times(2)).command();
    verify(this.log).debug("Sending message to client. [sessionId={},command={}]", "sessionId", Command.MESSAGE);
    verify(session).getBasicRemote();
    verify(basic).sendObject(frame);
    verifyNoMoreInteractions(msg, frame, session, basic);
}

@Test
public void fromBroker_ioe() throws IOException, EncodeException {
    final Message msg = mock(Message.class);
    when(msg.sessionId()).thenReturn("sessionId");
    final Frame frame = mock(Frame.class);
    when(msg.frame()).thenReturn(frame);
    when(frame.command()).thenReturn(Command.MESSAGE);
    final Session session = Mockito.mock(Session.class);
    getSessionMap().put("sessionId", session);
    getPrincipalSessionMap().put(NULL_PRINCIPLE, new HashSet<>(singleton(session)));
    final Basic basic = mock(Basic.class);
    when(session.getBasicRemote()).thenReturn(basic);
    final IOException ioe = new IOException();
    doThrow(ioe).when(basic).sendObject(frame);

    this.registry.fromBroker(msg);

    verify(msg).sessionId();
    verify(msg).frame();
    verify(frame, times(3)).command();
    verify(this.log).debug("Sending message to client. [sessionId={},command={}]", "sessionId", Command.MESSAGE);
    verify(session).getBasicRemote();
    verify(basic).sendObject(frame);
    verify(this.log).error("Unable to send message! [sessionid={},command={}]", "sessionId", Command.MESSAGE, ioe);
    verifyNoMoreInteractions(msg, frame, session, basic);
}

@OnMessage
public void onWebSocketText(final Session sess, final JSONRPC2Message msg) throws IOException, EncodeException {

    this.latestMessage = msg;

    if (msg instanceof JSONRPC2Request) {
        //All operations that are invokable on ContextManager that does not return void
        System.out.println("The message is a Request " + msg.toJSONString());
        final JSONRPC2Response data = new JSONRPC2Response(((JSONRPC2Request) msg).getID());
        final Map<String,String> result = Maps.newHashMap();
        result.put("decision", "valid");
        result.put("reason", "");
        data.setResult(result);
        sess.getBasicRemote().sendObject(data);
    }
    else if (msg instanceof JSONRPC2Notification) {
        //All operations that are invokable on ContextManager that does return void
        System.out.println("The message is a Notification " + msg.toJSONString());
    }
    else if (msg instanceof JSONRPC2Response) {
        //Can only be ContextChangesPending
        System.out.println("The message is a Response " + msg.toJSONString());
    }
}

/**
 * Try sending the {@link Message} using
 * {@link Session#getBasicRemote()}, {@link Basic#sendObject(Object)}.
 *
 * @param session Session to send the message on
 * @param message Message to send
 * @return true if send was successful, or false if it failed
 */
private boolean sendMessageToSession(Session session, Message message) {
    if (session.isOpen()) {
        try {
            session.getBasicRemote().sendObject(message);
            return true;
        } catch (EncodeException e) {
            // Something was wrong encoding this message, but the connection
            // is likely just fine.
            Log.log(Level.FINE, this, "Unexpected condition writing message", e);
        } catch (IOException ioe) {
            // An IOException, on the other hand, suggests the connection is
            // in a bad state.
            Log.log(Level.FINE, this, "Unexpected condition writing message", ioe);
            tryToClose(session, new CloseReason(CloseCodes.UNEXPECTED_CONDITION, trimReason(ioe.toString())));
        }
    }
    return false;
}

@Override
public String encode(AsciidocMessage m) throws EncodeException {
    StringWriter swriter = new StringWriter();
    try (JsonWriter jsonWrite = Json.createWriter(swriter)) {
        JsonObjectBuilder builder = Json.createObjectBuilder();
        builder.add("type", m.getType().toString())
                .add("adocId", m.getAdocId())
                .add("data",
                        Json.createObjectBuilder()
                                .add("format", m.getFormat().toString())
                                .add("source", m.getAdocSource())
                                .add("sourceToMerge", m.getAdocSourceToMerge()!=null?m.getAdocSourceToMerge():""));

        jsonWrite.writeObject(builder.build());
    }
    return swriter.toString();
}

@Override
public String encode(NotificationMessage m) throws EncodeException {
    StringWriter swriter = new StringWriter();
    try (JsonWriter jsonWrite = Json.createWriter(swriter)) {
        JsonObjectBuilder builder = Json.createObjectBuilder();
        builder.add("type", m.getType().toString()).
            add("adocId", m.getAdocId()).
            add(
                "data",
                Json.createObjectBuilder()
                .add("nbConnected", m.getNbConnected())
                 .add("nbWriters", m.getWriters().size())
                .add("writers", toJSON(m.getWriters())));

        jsonWrite.writeObject(builder.build());
    }
    return swriter.toString();
}

/**
 * Called when a message is received. The WebSocket container will take 
 * data from the socket, and will transform it into the parameter EchoObject
 * using the {@link EchoDecoder}.
 * @param o Parameters converted into an EchoObject via the <code>EchoDecoder</code>
 * @param session The session associated with this message
 * @throws IOException
 * @throws EncodeException
 */
@OnMessage
public void receiveMessage(EchoObject o, Session session)
        throws IOException, EncodeException {
    // Called when a message is received. 
    // Single endpoint per connection by default --> @OnMessage methods are single threaded!
    // Endpoint/per-connection instances can see each other through sessions.

    if (o.stopRequest()) {
        session.close();
    } else {
        // Simple broadcast
        for (Session s : session.getOpenSessions()) {
            s.getBasicRemote().sendObject(o);
        }
    }
}

/**
 * WebSocket session opened event handler.
 * 
 * @param session - Session that has been opened
 */
@OnOpen
public void open(Session session) {
    this.session = session;

    System.out.println("Session opened with ID: " + session.getId());

    BallotBox ballotBox = BallotBox.getInstance();
    ballotBox.addObserver(this);
    session.getUserProperties().put("ballotbox", ballotBox);

    try {
        notify(ballotBox);
    } catch (IOException | EncodeException e) {
        e.printStackTrace();
    }
}

/**
 * Try sending the {@link RoutedMessage} using
 * {@link Session#getBasicRemote()}, {@link Basic#sendObject(Object)}.
 *
 * @param session
 *            Session to send the message on
 * @param message
 *            {@link RoutedMessage} to send
 * @return true if send was successful, or false if it failed
 */
public static boolean sendMessage(Session session, RoutedMessage message) {
    if (session.isOpen()) {
        try {
            session.getBasicRemote().sendObject(message);
            return true;
        } catch (EncodeException e) {
            Log.log(Level.FINEST, session, "Unexpected condition writing message", e);
            // Something was wrong encoding this message, but the connection
            // is likely just fine.
        } catch (IOException ioe) {
            // An IOException, on the other hand, suggests the connection is
            // in a bad state.
            Log.log(Level.FINEST, session, "Unexpected condition writing message", ioe);
            tryToClose(session, new CloseReason(CloseCodes.UNEXPECTED_CONDITION, trimReason(ioe.toString())));
        }
    }
    return false;
}

@Override
public ByteBuffer encode(WebSocketMessage msg) throws EncodeException {
    Builder msgBuilder = MessageProtos.Message.newBuilder();
    if (msg.getEvent() != null && !"".equals(msg.getEvent()))
        msgBuilder.setEvent(msg.getEvent().toString());
    if (msg.getChannel() != null && !"".equals(msg.getChannel()))
        msgBuilder.setChannel(msg.getChannel());
    if (msg.getFrom() != null && !"".equals(msg.getFrom()))
        msgBuilder.setFrom(msg.getFrom());
    if (msg.getId() != null && !"".equals(msg.getId()))
        msgBuilder.setId(msg.getId());
    if (msg.getPayload() != null)
        msgBuilder.setData(ByteString.copyFrom(msg.getPayload()));

    return ByteBuffer.wrap(msgBuilder.build().toByteArray());
}

@Test
public void shouldEncodeObject() throws EncodeException {
    // given
    Message message = create()//
            .from("A")//
            .to("B")//
            .content("con")//
            .signal("sig")//
            .build();

    // when
    String result = encoder.encode(message);

    // then
    assertNotNull(result);
    assertThat(result, containsString(replaceQuotes("'content':'con'")));
    assertThat(result, containsString(replaceQuotes("'from':'A'")));
    assertThat(result, containsString(replaceQuotes("'to':'B'")));
    assertThat(result, containsString(replaceQuotes("'signal':'sig'")));
}

@Test
public void shouldEncodeObjectWithNullValues() throws EncodeException {
    // given
    Message message = create()//
            .from(null)//
            .to(null)//
            .build();

    // when
    String result = encoder.encode(message);

    // then
    assertNotNull(result);
    assertThat(result, not(containsString(replaceQuotes("'from'"))));
    assertThat(result, not(containsString(replaceQuotes("'to'"))));
}

protected final void processResult(Object result) {
    if (result == null) {
        return;
    }

    RemoteEndpoint.Basic remoteEndpoint = session.getBasicRemote();
    try {
        if (result instanceof String) {
            remoteEndpoint.sendText((String) result);
        } else if (result instanceof ByteBuffer) {
            remoteEndpoint.sendBinary((ByteBuffer) result);
        } else if (result instanceof byte[]) {
            remoteEndpoint.sendBinary(ByteBuffer.wrap((byte[]) result));
        } else {
            remoteEndpoint.sendObject(result);
        }
    } catch (IOException ioe) {
        throw new IllegalStateException(ioe);
    } catch (EncodeException ee) {
        throw new IllegalStateException(ee);
    }
}

protected final void processResult(Object result) {
    if (result == null) {
        return;
    }

    RemoteEndpoint.Basic remoteEndpoint = session.getBasicRemote();
    try {
        if (result instanceof String) {
            remoteEndpoint.sendText((String) result);
        } else if (result instanceof ByteBuffer) {
            remoteEndpoint.sendBinary((ByteBuffer) result);
        } else if (result instanceof byte[]) {
            remoteEndpoint.sendBinary(ByteBuffer.wrap((byte[]) result));
        } else {
            remoteEndpoint.sendObject(result);
        }
    } catch (IOException ioe) {
        throw new IllegalStateException(ioe);
    } catch (EncodeException ee) {
        throw new IllegalStateException(ee);
    }
}

protected final void processResult(Object result) {
    if (result == null) {
        return;
    }

    RemoteEndpoint.Basic remoteEndpoint = session.getBasicRemote();
    try {
        if (result instanceof String) {
            remoteEndpoint.sendText((String) result);
        } else if (result instanceof ByteBuffer) {
            remoteEndpoint.sendBinary((ByteBuffer) result);
        } else if (result instanceof byte[]) {
            remoteEndpoint.sendBinary(ByteBuffer.wrap((byte[]) result));
        } else {
            remoteEndpoint.sendObject(result);
        }
    } catch (IOException ioe) {
        throw new IllegalStateException(ioe);
    } catch (EncodeException ee) {
        throw new IllegalStateException(ee);
    }
}

/**
 * Send Live Match message for all peers connected to this match
 * @param msg
 * @param matchId
 */
public static void send(MatchMessage msg, String matchId) {
    try {
        /* Send updates to all open WebSocket sessions for this match */
        for (Session session : peers) {
            if (Boolean.TRUE.equals(session.getUserProperties().get(matchId))){
                if (session.isOpen()){
                session.getBasicRemote().sendObject(msg);
                 logger.log(Level.INFO, " Score Sent: {0}", msg);
                }
            }
        }
    } catch (IOException | EncodeException e) {
        logger.log(Level.INFO, e.toString());
    }   
}

@Override
public Future<MatlabResult> exec(MatlabRequest request)
        throws MatlabException, IOException {
    Preconditions.checkState(session != null && session.isOpen());
    try {
        SettableFuture<MatlabResult> future = SettableFuture.create();
        SettableFuture<MatlabResult> oldFuture
                = this.responses.putIfAbsent(request.getId(), future);

        if (oldFuture != null) {
            // we already executed that request...
            return oldFuture;
        }
        session.getBasicRemote().sendObject(request);
        return future;

    } catch (EncodeException ex) {
        throw new RuntimeException(ex);
    }
}

public void sendMessage(Message message) throws IOException, EncodeException {
    if (session == null) {
        System.out.println("debuger_delf: session is null");
    }
    session.getBasicRemote().sendObject(message);
    Log.d("delf", "[CLIENT] send message to server: " + message.toString());
}

private void handleSendFailure(Throwable t) throws IOException {
    try {
        handleSendFailureWithEncode(t);
    } catch (EncodeException e) {
        // Should never happen. But in case it does...
        throw new IOException(e);
    }
}

@Override
public ByteBuffer encode(MsgByte msg) throws EncodeException {
    byte[] data = msg.getData();
    ByteBuffer reply = ByteBuffer.allocate(2 + data.length);
    reply.put((byte) 0x12);
    reply.put((byte) 0x34);
    reply.put(data);
    reply.flip();
    return reply;
}

@Override
public String encode(List<String> str) throws EncodeException {
    StringBuffer sbuf = new StringBuffer();
    sbuf.append("[");
    for (String s: str){
        sbuf.append(s).append(",");
    }
    sbuf.deleteCharAt(sbuf.lastIndexOf(",")).append("]");
    return sbuf.toString();
}

@Test
public void testUnsupportedObject() throws Exception{
    Tomcat tomcat = getTomcatInstance();
    // No file system docBase required
    Context ctx = tomcat.addContext("", null);
    ctx.addApplicationListener(ProgramaticServerEndpointConfig.class.getName());
    Tomcat.addServlet(ctx, "default", new DefaultServlet());
    ctx.addServletMapping("/", "default");

    WebSocketContainer wsContainer = ContainerProvider.getWebSocketContainer();

    tomcat.start();

    Client client = new Client();
    URI uri = new URI("ws://localhost:" + getPort() + PATH_PROGRAMMATIC_EP);
    Session session = wsContainer.connectToServer(client, uri);

    // This should fail
    Object msg1 = new Object();
    try {
        session.getBasicRemote().sendObject(msg1);
        Assert.fail("No exception thrown ");
    } catch (EncodeException e) {
        // Expected
    } catch (Throwable t) {
        Assert.fail("Wrong exception type");
    } finally {
        session.close();
    }
}

public void notify(TodoChangedEvent e) throws EncodeException {
    ToDo todo = e.getTodo();
    String time = new SimpleDateFormat("HH:mm").format(new Date());
    Class<? extends TodoChangedEvent> aClass = e.getClass();

    ChangeEvent annotation = aClass.getAnnotation(ChangeEvent.class);
    ChangeEvent.Type value = annotation.value();
    SocketOutputMessage socketOutputMessage = new SocketOutputMessage(todo, value.toString(), time);
    template.convertAndSend("/topic/todos", socketOutputMessage);
}

/** Send change name message and name to server */
public void sendNicknameChangeMessage(String nickname) {
    Message changeNicknameMsg = new Message().setType(Message.REQUEST_CHANGE_NAME);
    changeNicknameMsg.add(Message.CHANGE_NAME, nickname);

    try {
        endpoint.sendMessage(changeNicknameMsg);
    } catch (IOException | EncodeException e) {
        e.printStackTrace();
    }
}

/** Send join group messgae and group key to server */
public void sendGroupJoinMessage() {
    if (groupKeyTF.getText().length() != 0) {

        Message signUpMsg = new Message().setType(Message.REQUEST_JOIN_GROUP);
        signUpMsg.add(Message.GROUP_PK, groupKeyTF.getText());
        try {
            endpoint.sendMessage(signUpMsg);
        } catch (IOException | EncodeException e) {
            e.printStackTrace();
        }
    }
}

public void sendWithout(String user, Message message) throws IOException, EncodeException {
    System.out.println("[Group] send message to all users of group except \"" + user + "\" : " + message.toString());
    for (String key : users.keySet()) {
        if (key.equals(user)) // except
            continue;
        users.get(key).getSession().getBasicRemote().sendObject(message);
    }
}

public boolean sendAll(Message message) throws IOException, EncodeException {
    if (users.size() == 0) {
        return true;
    }

    for (String key : users.keySet()) {
        users.get(key).getSession().getBasicRemote().sendObject(message);
    }
    return false;
}

private void handleSendFailure(Throwable t) throws IOException {
    try {
        handleSendFailureWithEncode(t);
    } catch (EncodeException e) {
        // Should never happen. But in case it does...
        throw new IOException(e);
    }
}

@Override
public ByteBuffer encode(MsgByte msg) throws EncodeException {
    byte[] data = msg.getData();
    ByteBuffer reply = ByteBuffer.allocate(2 + data.length);
    reply.put((byte) 0x12);
    reply.put((byte) 0x34);
    reply.put(data);
    reply.flip();
    return reply;
}

@Override
public String encode(List<String> str) throws EncodeException {
    StringBuffer sbuf = new StringBuffer();
    sbuf.append("[");
    for (String s: str){
        sbuf.append(s).append(",");
    }
    sbuf.deleteCharAt(sbuf.lastIndexOf(",")).append("]");
    return sbuf.toString();
}