1 /*
2 * Copyright (c) 2013 Oracle and/or its affiliates. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * - Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * - Neither the name of Oracle nor the names of its
16 * contributors may be used to endorse or promote products derived
17 * from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
20 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * This source code is provided to illustrate the usage of a given feature
34 * or technique and has been deliberately simplified. Additional steps
35 * required for a production-quality application, such as security checks,
36 * input validation and proper error handling, might not be present in
37 * this sample code.
38 */
39 package stream.data;
40
41 import java.io.File;
42 import java.util.ArrayList;
43 import java.util.List;
44 import javax.xml.bind.JAXBContext;
45 import javax.xml.bind.JAXBException;
46 import javax.xml.bind.Unmarshaller;
47 import javax.xml.bind.annotation.XmlElement;
48 import javax.xml.bind.annotation.XmlRootElement;
49
50 /**
51 * DataUtilities is a singleton helper class that creates test data. This class
52 * uses jaxws API to read xml into java object, which includes 3 list of data 1.
53 * Customers 2. Products 3. Vendors Note in this demo here we don't use stream
54 * API to change data, if we use stream API to populate source data, we should
55 * be aware this is not free and not thread-safe.
56 */
57 interface XMLList<E> {
58
59 public List<E> getList();
60 }
61
62 /**
63 * class for PRODUCTS_XML's root
64 */
65 @XmlRootElement(name = "products")
66 class Products implements XMLList<Product> {
67
68 /**
69 * node products only contains product list
70 */
71 @XmlElement(name = "product")
72 private ArrayList<Product> products;
73
74 /**
75 * product list
76 */
77 @Override
78 public List<Product> getList() {
79 return products;
80 }
81 }
82
83 /**
84 * class for VENDORS_XML's root
85 */
86 @XmlRootElement(name = "vendors")
87 class Vendors implements XMLList<Vendor> {
88
89 /**
90 * node Vendors only contains vendor list
91 */
92
93 @Override
94 public List<Vendor> getList() {
95 return vendors;
96 }
97
98 /**
99 * vendor list
100 */
101 @XmlElement(name = "vendor")
102 private ArrayList<Vendor> vendors;
103 }
104
105 /**
106 * class for CUSTOMERS_XML's root
107 */
108 @XmlRootElement(name = "customers")
109 class Customers implements XMLList<Customer> {
110
111 /**
112 * node customers only contains customer list
113 */
114 @Override
115 public List<Customer> getList() {
116 return customers;
117 }
118
119 /**
120 * customer list
121 */
122 @XmlElement(name = "customer")
123 private ArrayList<Customer> customers;
124 }
125
126 public class DataUtilities {
127
128 /**
129 * xml file name for Customers object
130 */
131
132 private final static String CUSTOMERS_XML = "Customers.xml";
133
134 /**
135 * xml file name for Products object
136 */
137 private final static String PRODUCTS_XML = "Products.xml";
138
139 /**
140 * xml file name for Products object
141 */
142 private final static String VENDORS_XML = "Vendors.xml";
143
144 /**
145 * Lazy initiate static inner class for
146 */
147 private static class UtilitiesHolder {
148
149 static DataUtilities instance = new DataUtilities();
150 }
151
152 /**
153 * private constructor is needed for singleton
154 */
155 private DataUtilities() {
156 }
157
158 //products
159 private List<Product> productList;
160
161 //customer
162 private List<Customer> customerList;
163
164 //vendors
165 private List<Vendor> vendorList;
166
167 /**
168 * Lazy initial to get product list
169 *
170 * @return initiated product list
171 */
172 public List<Product> getProductList() {
173 if (productList == null) {
174 createLists();
175 }
176 return productList;
177 }
178
179 /**
180 * Lazy initial to get customer list
181 *
182 * @return initiated customer list
183 */
184 public List<Customer> getCustomerList() {
185 if (customerList == null) {
186 createLists();
187 }
188 return customerList;
189 }
190
191 /**
192 * Lazy initial to get vendor list
193 *
194 * @return initiated vendor list
195 */
196 public List<Vendor> getVendorList() {
197 if (vendorList == null) {
198 createLists();
199 }
200 return vendorList;
201 }
202
203 /**
204 * convert xml files to java objects
205 */
206 private void createLists() {
207 customerList = xmlToObject(Customers.class, CUSTOMERS_XML);
208 productList = xmlToObject(Products.class, PRODUCTS_XML);
209 vendorList = xmlToObject(Vendors.class, VENDORS_XML);
210 }
211
212 /**
213 * Convert a xml file to instance of class by given file name
214 *
215 * @param clazz to be converted java object's class
216 * @param file xml file name
217 * @return a list of object that xml's root contains
218 */
219 private <U, V extends XMLList<U>> List<U> xmlToObject(Class<V> clazz,
220 String file) {
221 try {
222 JAXBContext context = JAXBContext.newInstance(clazz);
223 Unmarshaller um = context.createUnmarshaller();
224 @SuppressWarnings("unchecked")
225 V cs = (V) um.unmarshal(new File(file));
226 return cs.getList();
227 } catch (JAXBException ex) {
228 throw new RuntimeException(ex);
229 }
230 }
231
232 /**
233 * static factory method for singleton
234 *
235 * @return a DataUtitlities signgleton instance
236 */
237 public static DataUtilities getUtilities() {
238 return UtilitiesHolder.instance;
239 }
240 }