下面列出了javax.xml.bind.JAXBContext#newInstance ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Test
public void testGetPayloadOfJAXB() throws Exception {
//using Dispatch
JAXBContext ctx = JAXBContext.newInstance(ObjectFactory.class);
Message message = new MessageImpl();
Exchange e = new ExchangeImpl();
message.setExchange(e);
LogicalMessageContextImpl lmci = new LogicalMessageContextImpl(message);
JAXBElement<AddNumbers> el = new ObjectFactory().createAddNumbers(req);
LogicalMessageImpl lmi = new LogicalMessageImpl(lmci);
lmi.setPayload(el, ctx);
Object obj = lmi.getPayload(ctx);
assertTrue(obj instanceof JAXBElement);
JAXBElement<?> el2 = (JAXBElement<?>)obj;
assertTrue(el2.getValue() instanceof AddNumbers);
AddNumbers resp = (AddNumbers)el2.getValue();
assertEquals(req.getArg0(), resp.getArg0());
assertEquals(req.getArg1(), resp.getArg1());
}
@Test
public void testInvokeWithJAXBPayloadModeXMLBinding() throws Exception {
URL wsdl = getClass().getResource("/wsdl/addNumbers.wsdl");
assertNotNull(wsdl);
XMLService service = new XMLService();
assertNotNull(service);
JAXBContext jc = JAXBContext.newInstance("org.apache.hello_world_xml_http.wrapped.types");
Dispatch<Object> disp = service.createDispatch(portNameXML, jc, Mode.PAYLOAD);
setAddress(disp, greeterAddress);
TestHandlerXMLBinding handler = new TestHandlerXMLBinding();
addHandlersProgrammatically(disp, handler);
org.apache.hello_world_xml_http.wrapped.types.GreetMe req =
new org.apache.hello_world_xml_http.wrapped.types.GreetMe();
req.setRequestType("tli");
Object response = disp.invoke(req);
assertNotNull(response);
org.apache.hello_world_xml_http.wrapped.types.GreetMeResponse value =
(org.apache.hello_world_xml_http.wrapped.types.GreetMeResponse)response;
assertEquals("Hello tli", value.getResponseType());
}
@Test
public void testCreateJuddiUsers() throws Exception
{
System.out.println("testCreateJuddiUsers");
try {
JuddiUsers juddiUsers = new JuddiUsers();
juddiUsers.getUser().add(new User("anou_mana","password"));
juddiUsers.getUser().add(new User("bozo","clown"));
juddiUsers.getUser().add(new User("sviens","password"));
StringWriter writer = new StringWriter();
JAXBContext context = JAXBContext.newInstance(juddiUsers.getClass());
Marshaller marshaller = context.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
marshaller.marshal(juddiUsers, writer);
logger.info("\n" + writer.toString());
} catch (Exception e) {
logger.error(e.getMessage(),e);
Assert.fail("unexpected");
}
}
@Override
public Map<String, List<String>> getMetadataMapping() {
Map<String, List<String>> cachedMapping = this.getCacheWrapper().getMetadataMapping();
if (null != cachedMapping) {
return cachedMapping;
}
Map<String, List<String>> mapping = new HashMap<>();
try {
String xmlConfig = this.getConfigManager().getConfigItem(JacmsSystemConstants.CONFIG_ITEM_RESOURCE_METADATA_MAPPING);
InputStream stream = new ByteArrayInputStream(xmlConfig.getBytes(StandardCharsets.UTF_8));
JAXBContext context = JAXBContext.newInstance(JaxbMetadataMapping.class);
Unmarshaller unmarshaller = context.createUnmarshaller();
JaxbMetadataMapping jaxbMapping = (JaxbMetadataMapping) unmarshaller.unmarshal(stream);
jaxbMapping.getFields().stream().forEach(m -> {
String key = m.getKey();
String csv = m.getValue();
List<String> metadatas = (!StringUtils.isBlank(csv)) ? Arrays.asList(csv.split(",")) : new ArrayList<>();
mapping.put(key, metadatas);
});
this.getCacheWrapper().updateMetadataMapping(mapping);
} catch (Exception e) {
logger.error("Error Extracting resource metadata mapping", e);
throw new RuntimeException("Error Extracting resource metadata mapping", e);
}
return mapping;
}
public void postPerson(Person person) throws Exception{
System.out.println("\n### POST PERSON -> ");
HttpURLConnection connection = connect(PERSON_SERVICE_URL + "person/post/");
connection.setDoOutput(true);
connection.setRequestProperty("Content-Type", "application/xml");
JAXBContext jaxbContext = JAXBContext.newInstance(Person.class);
Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
// pretty xml output
jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
jaxbMarshaller.marshal(person, System.out);
jaxbMarshaller.marshal(person, connection.getOutputStream());
System.out.println("\n### POST PERSON RESPONSE");
System.out.println("Status: " + connection.getResponseCode() + " " +
connection.getResponseMessage());
System.out.println("Location: " + connection.getHeaderField("Location"));
}
@Override
public void setUp() {
try {
JAXBContext context = JAXBContext.newInstance(AtomFeed.class);
// File file = new File("test/testatom.xml");
File file = new File("test/flickr.atom");
feed = (AtomFeed) context.createUnmarshaller().unmarshal(file);
} catch (JAXBException e) {
e.printStackTrace();
}
}
/**
* Test handling of utf8 characters
*/
@Test
public void unmarshallUTF8()
{
try {
JAXBContext jaxbContext=JAXBContext.newInstance("org.uddi.api_v3");
Unmarshaller unMarshaller = jaxbContext.createUnmarshaller();
StringReader reader = new StringReader(EXPECTED_UTF8_XML_FRAGMENT1);
JAXBElement<AuthToken> utf8Element = unMarshaller.unmarshal(new StreamSource(reader),AuthToken.class);
String infoString = utf8Element.getValue().getAuthInfo();
assertEquals(UTF8_WORD, infoString);
} catch (JAXBException jaxbe) {
fail("No exception should be thrown");
}
}
private static JAXBContext getW3CJaxbContext() {
try {
return JAXBContext.newInstance(W3CEndpointReference.class);
} catch (JAXBException e) {
throw new WebServiceException("Error creating JAXBContext for W3CEndpointReference. ", e);
}
}
private static UserManagement convertXMLToUser(String xmlString) throws JAXBException {
JAXBContext jaxbContext = null;
jaxbContext = JAXBContext.newInstance(ObjectFactory.class);
Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
StringReader reader = new StringReader(xmlString);
UserManagement objectElement = (UserManagement) jaxbUnmarshaller.unmarshal(reader);
return objectElement;
}
private JAXBContext getJaxbContext ()
throws JAXBException
{
// Lazy creation
if (jaxbContext == null) {
jaxbContext = JAXBContext.newInstance(GlyphValue.class);
}
return jaxbContext;
}
private void setConfigFromXML() {
if (configurationFile.file().isPresent()) {
final File configFile = configurationFile.file().get();
log.debug("Reading configuration file {}", configFile);
try {
final Class<?>[] classes = ImmutableList.<Class<?>>builder().add(getConfigEntityClass())
.addAll(getInheritedEntityClasses())
.build()
.toArray(new Class<?>[0]);
final JAXBContext context = JAXBContext.newInstance(classes);
final Unmarshaller unmarshaller = context.createUnmarshaller();
//replace environment variable placeholders
String configFileContent = new String(Files.readAllBytes(configFile.toPath()), StandardCharsets.UTF_8);
configFileContent = envVarUtil.replaceEnvironmentVariablePlaceholders(configFileContent);
final ByteArrayInputStream is =
new ByteArrayInputStream(configFileContent.getBytes(StandardCharsets.UTF_8));
final StreamSource streamSource = new StreamSource(is);
setConfiguration(unmarshaller.unmarshal(streamSource, getConfigEntityClass()).getValue());
} catch (final Exception e) {
if (e.getCause() instanceof UnrecoverableException) {
if (((UnrecoverableException) e.getCause()).isShowException()) {
log.error("An unrecoverable Exception occurred. Exiting HiveMQ", e);
log.debug("Original error message:", e);
}
System.exit(1);
}
log.error("Could not read the configuration file {}. Using default config", configFile.getAbsolutePath());
log.debug("Original error message:", e);
setConfiguration(getDefaultConfig());
}
} else {
setConfiguration(getDefaultConfig());
}
}
@Override
public void activate(Context context)
{
try {
JAXBContext ctx = JAXBContext.newInstance(getClazz());
unmarshaller = ctx.createUnmarshaller();
if (schemaXSDFile != null) {
unmarshaller.setSchema(schema);
}
} catch (JAXBException e) {
DTThrowable.wrapIfChecked(e);
}
}
public void saveData(String routeId) {
Schema schema = null;
SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
try {
schema = sf.newSchema(new File("./data/static_data/npc_walker/npc_walker.xsd"));
}
catch (SAXException e1) {
log.error("Error while saving data: " + e1.getMessage(), e1.getCause());
return;
}
File xml = new File("./data/static_data/npc_walker/generated_npc_walker_" + routeId + ".xml");
JAXBContext jc;
Marshaller marshaller;
try {
jc = JAXBContext.newInstance(WalkerData.class);
marshaller = jc.createMarshaller();
marshaller.setSchema(schema);
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
marshaller.marshal(this, xml);
}
catch (JAXBException e) {
log.error("Error while saving data: " + e.getMessage(), e.getCause());
return;
}
finally {
if (walkerlist != null) {
walkerlist.clear();
walkerlist = null;
}
}
}
private Info getInfo(File infoFile) throws JAXBException {
if (infoFile == null) {
return null;
}
JAXBContext jaxbContext = JAXBContext.newInstance(Info.class);
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
return (Info) unmarshaller.unmarshal(infoFile);
}
@Test
public void contextIsSuccessfullyCreated() throws JAXBException {
final JAXBContext context = JAXBContext.newInstance(Gh1.class);
final Gh1 value = new Gh1();
value.getAs().add("a");
value.getBs().add(2);
value.getMixedContent().add("Test");
final StringWriter sw = new StringWriter();
context.createMarshaller().marshal(
new JAXBElement<Gh1>(new QName("test"), Gh1.class, value), System.out);
context.createMarshaller().marshal(
new JAXBElement<Gh1>(new QName("test"), Gh1.class, value), sw);
Assert.assertTrue(sw.toString().contains("Test"));
}
public static MessageSchema unmarshall(InputStream inputStream) throws SchemaUnmarshallingException {
try {
final JAXBContext jc = JAXBContext.newInstance(ObjectFactory.class.getPackage().getName());
final Unmarshaller unmarshaller = jc.createUnmarshaller();
final InputSource is = new InputSource(new InputStreamReader(inputStream));
final XMLReader reader = XMLReaderFactory.createXMLReader();
final NamespaceFilter filter = new NamespaceFilter(NAMESPACE, false);
filter.setParent(reader);
final SAXSource source = new SAXSource(filter, is);
unmarshaller.setEventHandler(event -> false);
return (MessageSchema) unmarshaller.unmarshal(source);
} catch (Exception e) {
throw new SchemaUnmarshallingException("Failed to parse MDP Schema: " + e.getMessage(), e);
}
}
@Before
public void setUp() throws Exception {
context = JAXBContext.newInstance(getClass().getPackage().getName());
}
private JAXBContext getSingleton() throws JAXBException {
if (jcSing == null)
jcSing = JAXBContext.newInstance(TestSuiteCorpus.class.getPackage()
.getName());
return jcSing;
}
private Repository unmarshal(final InputStream inputStream) throws JAXBException {
final JAXBContext jaxbContext = JAXBContext.newInstance(Repository.class);
final Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
jaxbUnmarshaller.setEventHandler(unmarshallerErrorHandler);
return (Repository) jaxbUnmarshaller.unmarshal(inputStream);
}
/**
* Initializes the {@link JAXBContext} for this format.
*
* @param classloader the classloader to load the generated JAXB classes with
* @throws JAXBException if a problem with JAXB occurred
*/
public synchronized static void initContext(ClassLoader classloader) throws JAXBException {
JAXB = JAXBContext.newInstance(PACKAGE, classloader);
}