1. Conocimiento de preparación
1. El horario de salvación de verano de América/new_york es el siguiente: la izquierda no es la derecha es
2016-3-13, 02:00:00 a 2016-11-6, 02:00:00
2017-3-12, 02:00:00 a 2017-11-5, 02:00:00
2. ID de zona horaria de tres letras
Para la compatibilidad con JDK 1.1.x, también son compatibles con algunas ID de zona horaria de tres letras (como "PST", "CTT", "AST").
Sin embargo, su uso se descarta porque la misma abreviatura a menudo se usa en múltiples zonas horarias
Por ejemplo, CST: tiene 4 significados, Estados Unidos, Australia, China, Cuba Time
3. Estándar
GMT: Tiempo medio verde Tiempo estándar de Greenwich, se usó como referencia de tiempo estándar GMT+12-> GMT-12 antes de 1960
El rango de Java8 es GMT+18-> GMT-18
UTC: tiempo de tiempo universal coordinado coordina el tiempo mundial, que es más preciso que GMT, y se convierte en el nuevo estándar el 1 de enero de 1972; UTC, UTC+1, UTC+2 ... UTC+12, UTC-12 ... UTC-1
Rango de Java8 UTC-18-> UTC+18
DST: El tiempo de ahorro de verano se refiere al momento en que el reloj se enciende durante una hora en el verano para usar la luz del sol antes. Se llama Summer Time en el Reino Unido;
Actualmente, más de 110 países usan el horario de verano;
En China, solo se implementó durante 6 años de 1986 a 1992, y se canceló después; Las razones son las siguientes:
1. China tiene un gran tramo en las direcciones este y oeste, y adopta un distrito unificado de East Octavo, que es incompatible con el este y el oeste utilizando el tiempo de ahorro de verano;
2. En áreas de alta latitud, la hora del día y la noche cambia enormemente en invierno y verano; No es muy significativo;
4. Se puede usar para indicar que el Octavo Distrito de East es: GMT+8 o Etc/GMT-8 (solo al revés, ¿por qué? Porque los desarrolladores de PHP creen que el Octavo Distrito de East es 8 horas más rápido que el tiempo estándar, y debe ser restado por 8 horas, por lo que la representación es así. Los diferentes objetos de referencia conducen a diferentes métodos de representación de representación);
5. Cómo representar la zona horaria de China
GMT+8
UTC+8
Asia/Harbin Harbin // Tiempo estándar de China
Asia/Chongqing Chongqing // Tiempo estándar de China
Asia/Chungking Chongqing // Tiempo estándar de China
Asia/Urumqi Urumqi // Tiempo estándar de China
Asia/Shanghai Shanghai (Distrito East 8) // Tiempo estándar de China
PRC
Asia/Macao Macao // Tiempo estándar de China
Hongkong Hong Kong // El tiempo de Hong Kong es consistente con el tiempo estándar de China
Asia/Hong_kong Hong Kong
Asia/Taipei Taipei (Taiwán) // El tiempo estándar de China Singapur es lo mismo que el tiempo de China;
Asia/Singapur
Singapur
6. Representación de zonas horarias estándar
UTC
UTC+0
UTC-0
GMT GMT
GMT0 GMT
ETC/GMT GMT
Etc/gmt+0 gmt
ETC/GMT-0 GMT
ETC/GMT0 GMT0 GMTS Tiempo estándar Nota: GMT+XX (-xx) es muy inclusivo y puede identificar automáticamente la representación de varios tiempos.
2. Conversión de la zona horaria
Medio ambiente: antes de Java8
1. Convierta la hora actual en la pantalla de zona horaria especificada
@Test public void test () lanza la excepción {fecha a = nueva fecha (); SimpleDateFormat sf = new SimpleDateFormat ("yyyy-mm-dd hh: mm: ss"); sf.settimezone (TimeZone.GetTimezone ("America/New_york")); // convertir la zona horaria china en la zona horaria de Nueva York del sistema de los Estados Unidos.out.println (SF.Format (a)); }2. El tiempo especificado se convierte en la pantalla de zona horaria especificada
¿Puedo realmente convertirme correctamente? Parece haber una trampa, miré la implementación en línea
Siento un pequeño problema con el horario de verano
// Método de implementación 1: El tiempo de ahorro de luz del día no se considera @Test public void test2 () lanza la excepción { /date dateTime = new SimpleDateFormat ("yyyyy-mm-dd hh: mm: ss"). Parse ("2016-11-6 14:00:00"); Date dateTime = new SimpleDateFormat ("aaa yyy-mm-dd hh: mm: ss"). Parse ("2016-10-6 14:00:00"); TimeZone Zhong = Timelone.GetTimezone ("GMT+8: 00"); // China Timelone York = TimEzone.GetTimezone ("America/New_york"); // GMT-5 // El desplazamiento de la zona horaria aquí es fija, no hay tiempo de guardado de verano, error Long Chinesemills = DateTime.GetTime () + York.getrawoffset ()-Zhong.getrawOffset (); Fecha fecha = nueva fecha (chinesemills); System.out.println (nuevo SimpleDateFormat ("yyyy-mm-dd hh: mm: ss"). Format (fecha)); } // Método de implementación 2 Puede recordar que usando calendario.dst_offset de la clase de calendario // todavía no es correcto al calendario.dst_offset Esto está muerto @testpublic void test3 () lanza la excepción {// date hora = nuevo simpleedAceformat ("yyyy-mm-dd hh: mm: ss"). Parse ("2016-11-6 14:00:00"//date; SimpledateFormat ("aaayyyy-mm-dd hh: mm: ss"). Parse ("2016-11-6 1:00:00"); // date hora = new SimpleDateFormat ("yyyy-mm-dd hh: mm: ss"). Parse ("2016-11-6 1:00:00:00"); // fecha de fecha = nueva simpledateFormat ("" yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy Hh: mm: ss "). Parse (" 2016-11-6 0:59:00 "); // date time = new SimpleDateFormat (" yyyyy-mm-dd hh: mm: ss "). Parse (" 2016-11-6 1:59:59 "); fecha de fecha = new SimpledateFormat (" yyyyy-mm-dd HH: MM: SS "). Parse (" 2016-11-6 3:00:00 "); // 1. Obtenga la hora local: calendario cal = calendar.getInstance (); cal.settime (tiempo); cal.setTimezone (timeZone.getTimezone (" America/new_york ")); // 2. Obtener el tiempo de tiempo: este es fijo fijo. cal.get (calendar.zone_offset)/(1000*60*60); // 3. Obtenga la diferencia de tiempo de ahorro de verano: esto se fija, no se basa en el juicio dinámico del tiempo. Mientras haya un tiempo de ahorro de luz de día en la zona horaria, es 1int dstoffset = cal.get (calendar.dst_offset)/(1000*60*60); system.out.println (ZoneOffset); System.out.println (dstoffset); // 4. Deducta estas diferencias del tiempo local para obtener el tiempo UTC: //cal.add(CalendAR. -(ZoneOffSet + dstoffset)); cal.add (calendar.hour, -(ZoneOffset + dstoffset)); fecha de fecha2 = cal.gettime (); system.out.println (new SimpleDateFormat ("yyyyy -mm -dd hh: mm: ss"). format (tiempo2));} // Método de implementación 3 Preparación // ¿No se dice que Java manejará automáticamente el horario de verano para nosotros? // Primero tengamos una prueba simple para ver si el método de juicio de tiempo de ahorro de luz es correcto, y puede inferir si el procesamiento automático de Java es correcto // se sabe que en 2016: America/New_york's Daylight Time es: 2016-3-3-13 02:00:00 a 2016-11-06 01:59:59 @Test Void Test Void SimpleDateFormat sf = new SimpleDateFormat ("yyyy-mm-dd hh: mm: ss"); sf.settimezone (TimeZone.GetTimezone ("GMT+0")); // Date DateTime = Sf.Parse ("2016-11-6 5:59:59"); Fecha d1 = sf.parse ("2016-03-13 6:59:59"); // False fecha d2 = sf.parse ("2016-03-13 7:00:00"); // Fecha verdadera d3 = sf.parse ("2016-11-6 6:59:59"); // False d4 = sf.parse ("2016-11-6 7:00:00" Descubrí que de hecho no hay ningún problema en juzgar el comienzo del tiempo de ahorro de verano, pero para la hora final del horario de verano, para ser precisos, lo he juzgado con una hora de anticipación // mire la verificación a continuación, entonces, ¿por qué está con una hora de anticipación? ¿Cómo resolverlo? En la actualidad, solo puedo usar java8 d3 = sf.parse ("2016-11-6 5:59:59"); // true d4 = sf.parse ("2016-11-6 6:00:00"); // False TimeZone York = TimeZone.GetTimezone ("America/New_york"); // GMT-5 System.out.println ("¿La zona horaria de Target usa el tiempo de ahorro de luz del día:"+ISDAYLING (York, D1)); System.out.println ("¿La zona horaria de destino usa el tiempo de ahorro de la luz del día:"+Isdaylight (York, D2)); System.out.println ("¿La zona horaria de Target usa el tiempo de ahorro de luz del día:"+Isdaylight (York, D3)); System.out.println ("¿La zona horaria de destino usa el tiempo de ahorro de luz del día:"+ISDAYLIGHT (York, D4)); } // juzga si el día de booleano privado (zona de zona horaria, fecha de fecha) {return zone.usedaylighttime () && zone.indaylighttime (fecha); } // Método de implementación 3 // a través de la verificación anterior, sabemos que el juicio del sistema es problemático. Al establecer la zona horaria, el programa maneja automáticamente el horario de verano. At least I can't understand why @Testpublic void test5() throws Exception { //13 hours apart China + 8 New York-5 ChangeZone("2016-3-13 14:59:59", "PRC","America/New_York", "yyyy-MM-dd HH:mm:ss");//2016-03-13 01:59:59 ChangeZone("2016-3-13 15:00:00 "," PRC "," America/New_york "," aaa yyyy-mm-dd hh: mm: ss "); // 2016-03-13 03:00:00 Changzone (" 2016-11-6 13:59:59 "," PRC "," América/New_york "," Yyyy-Mm-DD HH: MM: SS: SS://///201); 01:59:59 // Este resultado es incorrecto, debería ser 02:00:00 ChangeZone ("2016-11-6 14:00:00", "PRC", "America/New_york", "yyyy-mm-dd hh: mm: ss"); // 2016-11-06 01:00:00} // La implementación específica es la siguiente: Tiempo, String Srcid, String Destid, Patrón de cadena) arroja ParseException {// Establecer la zona horaria de zona horaria predeterminada = TimEzone.gettimezone (srcid); TimeZone.SetDefault (Zona); Fecha date = new SimpleDateFormat (Patrón) .Parse (hora); // Establecer la zona horaria de la zona horaria de destino Destzone = TimeZone.gettimezone (Destid); SimpleDateFormat sdf = new SimpleDateFormat (patrón); // Establecer la zona horaria para formatearse sdf.settimezone (Destzone); String changtime = sdf.format (fecha); // Obtenga la zona horaria de destino System.out.println ("Después de modificar la zona horaria" + Destzone.getID () + "Time:" + Changtime); }Resumen: Los resultados obtenidos por los tres métodos de implementación anteriores son algo problemáticos para el tiempo de ahorro de verano
Tres, implementación de Java8
1. Echemos un vistazo a los cambios de la zona horaria en Java 8 primero
// La zona horaria disponible de JDK8 @TestPublic Void testName1 () lanza la excepción {// JDK8 Las zonas de tiempo establecidas <String> ids = ZoneId.getAVailableZoneIds (); String [] id1 = id.toarray (new String [id.size ()]); ",]"); System.out.println (id.size ()); // 28 zonas horarias faltantes antes de la cadena de JDK8 [] id2 = TimEzone.getAVailableIds (); System.out.println (id2.length); // 623 // Informe el for (String id: id2) {if (! Idss.contains (id+",")) {system.out.print (id+",");}} // AGT, Art, AST, BET, BST, CAT, CNT, CST, CTT, EAT, ECT, IET, IST, JST, MIT, NET, NST, PLT, PNT, PRT, PST, SST, VST, // Pero estos nombres cortos todavía están disponibles, simplemente no están disponibles en la lista de soporte localDatetime Date = LocalDateTime.ofinstant (instant.now (), zoneid.of (zoneid.short_ids.get ("pst"))); system.out.println ("/ndate =" + fecha);}2. Cómo agregar información de la zona horaria o convertirla
// localDate, localDateTime, Información de la zona horaria instantánea @TestPublic Void testName3 () {localDate date = localDate.Now (); // localDate Agregar información de zona horaria // Método 1ZonedDatetime Zone = date.atstartofday (ZoneId.of ("GMT+08: 00"); System.out.Println (Zona); date.atStartOfday (ZoneId.SystemDefault ()); System.out.println (Zone); // Método 2 Date Date2 = LocalDate.Now (ZoneId.of ("GMT+0")); System.out.println (date2); System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- zoneIME3 = localDateTime.Now (Clock.System (ZoneID.Of ("GMT+0")));/Método 4ZonedDateTime Zonenetime4 = ZonedDateTime.of (Time, ZoneId.of ("GMT+0"); System.out.Println (Zonetime); System.out.println (Zonetime3); // Cambiar System.out.println (Zonetime4); // Cambiar System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------3. Cómo obtener el tiempo especificado de la hora actual (prueba omitida)
// Obtenga la zona horaria especificada de la hora actual, punto de referencia: 0 Zona horaria local Datetime GetCurrentZonetime (ZoneId Dest) {Objects.RequirenonNull (Dest); LocalDateTime Time2 = localDateTime.now (Clock.System (Dest)); Cadena zonedesc = getzonedesc (TimeZone.gettimezone (Dest)); System.out.println (Dest.getID ()+"corresponde a la zona horaria estándar:"+Zonedesc); System.out.println ("Zona horaria de Target"+Dest+"Time"+Time2.Format (DateTimeFormatter.OfPattern ("yyyyy-mm-dd hh: mm: ss"))); Time2;} // Obtenga la zona horaria estándar, método 1 // El método antes de JDK8, use la cadena estática privada de zona horaria getzonedesc (TimeZone Destzone) {Objects.RequirenonNull (Destzone); int offset = Destzone.getrawoffset () / (1000 * 60 * 60); if (offset <= 0) {return "gmt"+string.valueOf (offset); } else {return "gmt +" + string.valueOf (offset); }} // método Java8, método 2, use zonerules // Obtenga el desplazamiento estándar de la zona horaria, zonerules.getStandardOffset // Obtenga el desplazamiento real de la zona horaria (el desplazamiento obtenido cambiará de acuerdo con la hora de guardar luz del día) // Obtenga el desplazamiento estándar de la zona horaria (el desplazamiento resultante cambiará de acuerdo con el tiempo de ahorro de luz del día) // obtendrá el desplazamiento estándar de la desplazamiento de la zona horaria = regla.getStandarDOffset (ZonedDateTime.Now (Dest) .ToInstant ()). getId (); Cadena S = StandardOffset.split (":") [0]; int offset = Integer.ParseInt (s); // Método de retorno 1: con horas y minutos // devolver "GMT"+StandardOffset; // Método de retorno 2: con horas solo if (offset> 0) {return "gmt+"+offset;} else {return "gmt"+offset;}}4. Cómo obtener el tiempo especificado de la zona horaria especificada
Comience a implementar el problema de la zona horaria que queda anteriormente
Del mismo modo, veamos primero si el método de juicio de horario de verano con Java8 es correcto.
// Escribe una primera mano para determinar si el tiempo en los Estados Unidos está en la luz del día que ahorra tiempo público boolean isdaylighttime (localdatetime a) {objetos.requirenonnull (a); LocalDateTime StartDate = A.WithMonth (3) .tolocalDate (). Atime (2, 0); LocalDateTime startlightday = startDate.with (temporaladjusters.dayofweekinmonth (2, dayofweek.sunday)); // Actualizar a noviembre LocalDatetime EndDate = a.withmonth (11) .tolocaldate (). Atime (1, 59,59); LocalDatetime Endlightday = enddate.with (temporaladjusters.dayofweekinmonth (1, dayofweek.sunday)); if (a.isbefore (startlightday) || a.isafter (endlightday)) {system.out.println ("no en el tiempo de salvación de día"+a); return foals;} system.out.println ("en el día de día"+a); Java8 ya hay un método listo, que es mejor que el mío // pasar en la zona horaria y horaria de la zona horaria boolean iSdaylighttime (localDateTime a, zoneid dest) {zoneddatetime z1 = a.atzone (dest); // o transferir de esta manera // ZonedDateTime Z2 = ZonedDateTime.of (a, Dest); System.out.println (Z1.Format (DateTimeFormatter.OfPattern ("aaa yyyy-mm-dd hh: mm: ss"))); Reglas Zonerules = Dest.GetRules (); Boolean Flag = Rules.isdaylightSavings (z1.toinstant ()); System.out.println (bandera); return flag; }// Pruébelo y descubrió que el método de tiempo de ahorro de verano de Java8 es completamente correcto
// se sabe que 2016: America/New_york's Saving Saving Time es: 2016-3-13 02:00:00 a 2016-11-06 01:59:59 // (el segundo domingo de marzo y el primer domingo de noviembre de cada año) @testpublic void testName () arroja una excepción {// localDateTime a = localdatime.now (); LocalDateTime A2 = LocalDateTime.Of (2016, 3, 13, 1, 59,59); LocalDateTime a3=LocalDateTime.of(2016, 3, 13, 2, 00);LocalDateTime a4=LocalDateTime.of(2016, 11, 6, 1, 59,59);LocalDateTime a5=LocalDateTime.of(2016, 11, 6, 2, 0,0); // isdaylighttime (a2); // isdaylighttime (a3); // isdaylighttime (a4); // isdaylighttime (a5); sistema.out.println ("==================================================================================================================================================================================================================================. ================================================================================ ================================================================================ ================================================================================ ================================================================================ ================================================================================ ================================================================================ ); // falseisdaylighttime (a3, zoneid.of ("America/new_york")); // trueisDaylighttime (A4, ZoneId.of ("America/New_york")); // TrueisDaylightTime (A5, ZoneId.of ("America/New_york")); // Fasle}Comience a implementar:
Versión 1:
// Obtenga el punto de referencia de tiempo especificado para el tiempo especificado: Zona horaria predeterminada LocalDateTime Getzongtime (LocalDateTime Time, ZoneId Dest) {Objects.RequirenonNull (Dest); regresar getzongtime (tiempo, nulo, dest); } // No puede restar de ZonedDatetime de 2 zonas horarias, porque una vez que especifica la zona horaria aquí, ese tiempo es esta zona horaria local DatetEtime GetZongtime (LocalDateTime Time, ZoneId SRC, ZoneId Dest) {// La dificultad es cómo encontrar el desactivado // La zona horaria predeterminada aquí es China, y los Estados Unidos son los Estados Unidos. Esto probablemente sea más adecuado para objetos. Requirenonnull (Dest); ZonedDatetime Z1 = NULL; if (src == null) {z1 = time.atzone (ZoneID.SystemDefault ()); } else {z1 = time.atzone (src); } // La respuesta de la zona horaria cambia en el tiempo ZonedDateTime Z2 = Z1.WithZonesAnstant (Dest); System.out.println (Dest.getID ()+"corresponde a la zona horaria estándar:"+getzonedesc (TimeZone.gettimezone (Dest))); System.out.println ("Zona de tiempo de destino"+Dest+"Tiempo"+Z2.Format (DatetimeFormatter.OfPattern ("aaa yyyy-mm-dd hh: mm: ss"))); System.out.println ("-----------------"); tiempo de regreso; }La prueba es la siguiente:
@Test public void test6 () lanza la excepción {// Se espera que no esté en el horario de verano2016-03-13 01:59:59 LocalDateTime Time4 = LocalDatetime.of (2016, 3, 13, 14, 59, 59); getzongtime (Time4, ZoneId.of ("America/New_york")); // se espera que esté en el horario de verano2016-03-13 03:00:00 LocalDatetime Time1 = LocalDateTime.of (2016, 3, 13, 15, 00, 00); getzongtime (Time1, ZoneId.of ("America/New_york")); // El resultado esperado en el horario de verano: 2016-11-06 01:59:59 // Siento que fallé nuevamente, debería ser 2016-11-06 02:59:59 // En otras palabras, el método antes de Java8 maneja el final de la hora de salvación de día en este momento es exactamente lo mismo, y juzgar una hora antes // es decir, el tiempo de fin de día de fin de día se considera el tiempo de salvación de día de día en 2016-11- 00:59:59, pero el método de juicio de Java8 es correcto. ¿No es un poco extraño LocalDatetime Time2 = localDateTime.Of (2016, 11, 6, 14, 59, 59); getzongtime (Time2, ZoneId.of ("America/New_york")); // No se espera que esté en el horario de verano2016-11-06 02:00:00 LocalDatetime Time3 = LocalDateTime.of (2016, 11, 6, 15, 00, 00); getzongtime (Time3, ZoneId.of ("America/New_york")); }Así que ahora dudo si este resultado es un problema de cálculo sistemático, ¿o no entiendo la aduana de Nueva York?
Pero aún puedo obtener los resultados que quiero, usar 2 métodos:
WithearlierOffSetAtoverLap (), withlaterOffSetAtoverLap ()
Versión 2:
// Obtenga el punto de referencia de tiempo especificado para el tiempo especificado: la zona horaria predeterminada pública localDateTime getZongTime2 (localDateTime Time, ZoneId Dest) {Objects.RequirenonNull (Dest); return getzongtime2 (tiempo, null, dest);} // Versión 2 localDateTetTime GetZong Time2 (localDatetEd Time, ZoneId SRC, ZONEID Dest) Offset // La zona horaria predeterminada se usa aquí, en China, en los Estados Unidos, Estados Unidos es Estados Unidos, por lo que probablemente sea más adecuado para objetos. Requirenonnull (Dest); ZonedDatetime Z1 = NULL; if (src == null) {z1 = time.atzone (ZoneID.SystemDefault ()); } else {z1 = time.atzone (src); } // zonedDateTime z2 = z1.withzonesameInstant (dest); // manejar problemas de superposición largas horas = duración. z2 = z2.plushours (horas); System.out.println (Dest.getID ()+"corresponde a la zona horaria estándar:"+getzonedesc (TimeZone.gettimezone (Dest))); System.out.println ("Zona de tiempo de destino"+Dest+"Tiempo"+Z2.Format (DatetimeFormatter.OfPattern ("aaa yyyy-mm-dd hh: mm: ss"))); System.out.println ("-------------------"); tiempo de retorno;}Prueba: OK
@Test public void test4 () lanza la excepción {// Se espera que no esté en el horario de verano2016-03-13 01:59:59 LocalDateTime Time4 = LocalDatetime.of (2016, 3, 13, 14, 59, 59); getzongtime2 (Time4, ZoneId.of ("America/New_york")); // se espera que esté en el horario de verano2016-03-13 03:00:00 LocalDatetime Time1 = LocalDateTime.of (2016, 3, 13, 15, 00, 00); getzongtime2 (Time1, ZoneId.of ("America/New_york")); // Se espera que esté en el horario de verano 2016-11-06 02:59:59 LocalDateTime Time2 = LocalDateTime.of (2016, 11, 6, 14, 59, 59); getzongtime2 (Time2, ZoneId.of ("America/New_york")); // se espera que no sea en el horario de verano 2016-11-06 02:00:00 LocalDatetime Time3 = localDateTime.of (2016, 11, 6, 15, 00, 00); getzongtime2 (Time3, ZoneId.of ("America/New_york")); }resultado:
America/New_york corresponde a la zona horaria estándar: GMT-5
Tiempo de la zona horaria de Target America/New_York 2016-03-13 01:59:59
----------------------
America/New_york corresponde a la zona horaria estándar: GMT-5
Tiempo de la zona horaria de Target America/New_York 2016-03-13 03:00:00
----------------------
America/New_york corresponde a la zona horaria estándar: GMT-5
Tiempo de la zona horaria de Target America/New_York 2016-11-06 02:59:59
----------------------
America/New_york corresponde a la zona horaria estándar: GMT-5
Tiempo de la zona horaria de Target America/New_York 2016-11-06 02:00:00
----------------------
El problema anterior y la solución para convertir el horario de verano basado en la zona horaria de Java es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.