diff --git a/applications/content/src/main/java/org/apache/ofbiz/content/survey/PdfSurveyServices.java b/applications/content/src/main/java/org/apache/ofbiz/content/survey/PdfSurveyServices.java
index 428557a..26041e2 100644
--- a/applications/content/src/main/java/org/apache/ofbiz/content/survey/PdfSurveyServices.java
+++ b/applications/content/src/main/java/org/apache/ofbiz/content/survey/PdfSurveyServices.java
@@ -455,7 +455,7 @@
     }
 
     /**
-     * Returns list of maps with "question"->SurveyQuestion and "response"->SurveyResponseAnswer
+     * Returns list of maps with "question" -&gt; SurveyQuestion and "response" -&gt; SurveyResponseAnswer
      */
     public static Map<String, Object> buildSurveyQuestionsAndAnswers(DispatchContext dctx, Map<String, ? extends Object> context) {
         Delegator delegator = dctx.getDelegator();
diff --git a/applications/content/src/main/java/org/apache/ofbiz/content/webapp/ftl/RenderSubContentTransform.java b/applications/content/src/main/java/org/apache/ofbiz/content/webapp/ftl/RenderSubContentTransform.java
index 80a5e55..297bfd7 100644
--- a/applications/content/src/main/java/org/apache/ofbiz/content/webapp/ftl/RenderSubContentTransform.java
+++ b/applications/content/src/main/java/org/apache/ofbiz/content/webapp/ftl/RenderSubContentTransform.java
@@ -53,11 +53,10 @@
 
     /**
      * @deprecated use FreeMarkerWorker.getArg()
-     * Does a conditional search to return a value for a parameter with the passed name. Looks first to see if it was passed as an argument to the transform.
-     * Secondly, it looks to see if it is passed as a parameter in the template context object.
-     * <p/>
-     * Note that this is different from the getArg method of EditRenderDataResourceTransform, which checks the request object instead of the template context
-     * object.
+     * <p>Does a conditional search to return a value for a parameter with the passed name. Looks first to see if it was passed as an argument to the transform.
+     * Secondly, it looks to see if it is passed as a parameter in the template context object.</p>
+     * <p>Note that this is different from the getArg method of EditRenderDataResourceTransform, which checks the request object instead of the template context
+     * object.</p>
      */
     @Deprecated
     public static String getArg(Map<String, Object> args, String key, Environment env) {
diff --git a/applications/order/src/main/java/org/apache/ofbiz/order/order/OrderReadHelper.java b/applications/order/src/main/java/org/apache/ofbiz/order/order/OrderReadHelper.java
index e0ad51d..3030b7b 100644
--- a/applications/order/src/main/java/org/apache/ofbiz/order/order/OrderReadHelper.java
+++ b/applications/order/src/main/java/org/apache/ofbiz/order/order/OrderReadHelper.java
@@ -207,8 +207,8 @@
     }
 
     /**
-     * Returns a Map of paymentMethodId -> amount charged (BigDecimal) based on PaymentGatewayResponse.
-     * @return returns a Map of paymentMethodId -> amount charged (BigDecimal) based on PaymentGatewayResponse.
+     * Returns a Map of paymentMethodId -&gt; amount charged (BigDecimal) based on PaymentGatewayResponse.
+     * @return returns a Map of paymentMethodId -&gt; amount charged (BigDecimal) based on PaymentGatewayResponse.
      */
     public Map<String, BigDecimal> getReceivedPaymentTotalsByPaymentMethod() {
         Map<String, BigDecimal> paymentMethodAmounts = new HashMap<String, BigDecimal>();
@@ -252,8 +252,8 @@
     }
 
     /**
-     * Returns a Map of paymentMethodId -> amount refunded
-     * @return returns a Map of paymentMethodId -> amount refunded
+     * Returns a Map of paymentMethodId -&gt; amount refunded
+     * @return returns a Map of paymentMethodId -&gt; amount refunded
      */
     public Map<String, BigDecimal> getReturnedTotalsByPaymentMethod() {
         Map<String, BigDecimal> paymentMethodAmounts = new HashMap<String, BigDecimal>();
@@ -2720,7 +2720,7 @@
     }
 
     /**
-     * Get the total return adjustments for a set of key -> value condition pairs.  Done for code efficiency.
+     * Get the total return adjustments for a set of key -&gt; value condition pairs.  Done for code efficiency.
      * @param delegator the delegator
      * @param condition a map of the conditions to use
      * @return Get the total return adjustments
diff --git a/applications/order/src/main/java/org/apache/ofbiz/order/order/OrderReturnServices.java b/applications/order/src/main/java/org/apache/ofbiz/order/order/OrderReturnServices.java
index 29c8f36..eea6495 100644
--- a/applications/order/src/main/java/org/apache/ofbiz/order/order/OrderReturnServices.java
+++ b/applications/order/src/main/java/org/apache/ofbiz/order/order/OrderReturnServices.java
@@ -2188,7 +2188,7 @@
     }
 
     /**
-     * Takes a List of returnItems and returns a Map of orderId -> items and a Map of orderId -> orderTotal
+     * Takes a List of returnItems and returns a Map of orderId -&gt; items and a Map of orderId -&gt; orderTotal
      * @param returnItems a List of return items
      * @param returnItemsByOrderId the return items by order id
      * @param totalByOrder the total by order id
@@ -2548,7 +2548,7 @@
     }
 
     /**
-     * Get the total return adjustments for a set of key -> value condition pairs.  Done for code efficiency.
+     * Get the total return adjustments for a set of key -&gt; value condition pairs.  Done for code efficiency.
      * @param delegator the delegator
      * @param condition the conditions to use
      * @return return the total return adjustments
diff --git a/applications/order/src/main/java/org/apache/ofbiz/order/order/OrderServices.java b/applications/order/src/main/java/org/apache/ofbiz/order/order/OrderServices.java
index d2e1519..860f316 100644
--- a/applications/order/src/main/java/org/apache/ofbiz/order/order/OrderServices.java
+++ b/applications/order/src/main/java/org/apache/ofbiz/order/order/OrderServices.java
@@ -5688,10 +5688,9 @@
 
     /**
      * Create an OrderItemShipGroup record
-     * @param ctx
+     * @param dctx
      * @param context
      * @return
-     * @throws GenericEntityException 
      */
     public static Map<String, Object> addOrderItemShipGroup(DispatchContext dctx, Map<String, Object> context) {
         Delegator delegator = dctx.getDelegator();
@@ -5896,7 +5895,7 @@
 
     /**
      * Update orderItem and shipgroup association
-     * @param ctx
+     * @param dctx
      * @param context
      * @return
      * @throws GeneralException 
diff --git a/applications/order/src/main/java/org/apache/ofbiz/order/shoppingcart/ShoppingCartEvents.java b/applications/order/src/main/java/org/apache/ofbiz/order/shoppingcart/ShoppingCartEvents.java
index a35132f..3761057 100644
--- a/applications/order/src/main/java/org/apache/ofbiz/order/shoppingcart/ShoppingCartEvents.java
+++ b/applications/order/src/main/java/org/apache/ofbiz/order/shoppingcart/ShoppingCartEvents.java
@@ -967,7 +967,7 @@
         return cart;
     }
 
-    /** Main get cart method; uses the locale & currency from the session */
+    /** Main get cart method, uses the locale and currency from the session */
     public static ShoppingCart getCartObject(HttpServletRequest request) {
         return getCartObject(request, null, null);
     }
diff --git a/applications/product/src/main/java/org/apache/ofbiz/product/category/ftl/CatalogUrlSeoTransform.java b/applications/product/src/main/java/org/apache/ofbiz/product/category/ftl/CatalogUrlSeoTransform.java
index f2c7a8f..e236fca 100644
--- a/applications/product/src/main/java/org/apache/ofbiz/product/category/ftl/CatalogUrlSeoTransform.java
+++ b/applications/product/src/main/java/org/apache/ofbiz/product/category/ftl/CatalogUrlSeoTransform.java
@@ -484,12 +484,13 @@
 
     /**
      * Forward a uri according to forward pattern regular expressions.
-     * 
-     * @param uri
-     *            String to reverse transform
+     * @param request
+     * @param response
+     * @param delegator
+     * @param controlServlet
      * @return boolean to indicate whether the uri is forwarded.
-     * @throws IOException
      * @throws ServletException
+     * @throws IOException
      */
     public static boolean forwardUri(HttpServletRequest request, HttpServletResponse response, Delegator delegator, String controlServlet) throws ServletException, IOException {
         String pathInfo = request.getRequestURI();
@@ -605,12 +606,13 @@
 
     /**
      * Forward a category uri according to forward pattern regular expressions.
-     * 
-     * @param uri
-     *            String to reverse transform
-     * @return String
-     * @throws IOException
+     * @param request
+     * @param response
+     * @param delegator
+     * @param controlServlet
+     * @return
      * @throws ServletException
+     * @throws IOException
      */
     public static boolean forwardCategoryUri(HttpServletRequest request, HttpServletResponse response, Delegator delegator, String controlServlet) throws ServletException, IOException {
         String pathInfo = request.getRequestURI();
@@ -668,7 +670,7 @@
      * @param wrapper
      * @param prefix
      * @param contextPath
-     * @param productCategoryId
+     * @param currentCategoryId
      * @param previousCategoryId
      * @param productId
      * @return
@@ -755,7 +757,7 @@
      * @param delegator
      * @param wrapper
      * @param prefix
-     * @param productCategoryId
+     * @param currentCategoryId
      * @param previousCategoryId
      * @param productId
      * @param viewSize
diff --git a/framework/base/src/main/java/org/apache/ofbiz/base/location/FlexibleLocation.java b/framework/base/src/main/java/org/apache/ofbiz/base/location/FlexibleLocation.java
index 8d3bea4..f6a35f6 100644
--- a/framework/base/src/main/java/org/apache/ofbiz/base/location/FlexibleLocation.java
+++ b/framework/base/src/main/java/org/apache/ofbiz/base/location/FlexibleLocation.java
@@ -88,7 +88,7 @@
      *
      * The general format of the location is like a URL: {locationType}://location/path/file.ext
      *
-     * Supports standard locationTypes like http, https, ftp, jar, & file
+     * Supports standard locationTypes like http, https, ftp, jar and file
      * Supports a classpath location type for when desired to be used like any other URL
      * Supports OFBiz specific location types like ofbizhome and component
      * Supports additional locationTypes specified in the locationresolvers.properties file
diff --git a/framework/base/src/main/java/org/apache/ofbiz/base/util/string/UelFunctions.java b/framework/base/src/main/java/org/apache/ofbiz/base/util/string/UelFunctions.java
index 88da249..c67cb1a 100644
--- a/framework/base/src/main/java/org/apache/ofbiz/base/util/string/UelFunctions.java
+++ b/framework/base/src/main/java/org/apache/ofbiz/base/util/string/UelFunctions.java
@@ -49,7 +49,7 @@
 /** Implements Unified Expression Language functions.
  * <p>Built-in functions are divided into a number of
  * namespace prefixes:</p>
- * <table border="1">
+ * <table border="1" summary="">
  * <tr><td colspan="2"><b><code>date:</code> contains miscellaneous date/time functions</b></td></tr>
  * <tr><td><code>date:second(Timestamp, TimeZone, Locale)</code></td><td>Returns the second value of <code>Timestamp</code> (0 - 59).</td></tr>
  * <tr><td><code>date:minute(Timestamp, TimeZone, Locale)</code></td><td>Returns the minute value of <code>Timestamp</code> (0 - 59).</td></tr>
diff --git a/framework/base/src/main/java/org/apache/ofbiz/base/util/string/UelUtil.java b/framework/base/src/main/java/org/apache/ofbiz/base/util/string/UelUtil.java
index 25f041b..099f38e 100644
--- a/framework/base/src/main/java/org/apache/ofbiz/base/util/string/UelUtil.java
+++ b/framework/base/src/main/java/org/apache/ofbiz/base/util/string/UelUtil.java
@@ -72,7 +72,6 @@
      * @param context Evaluation context (variables)
      * @param expression UEL expression
      * @return Result object
-     * @throws <code>javax.el.*</code> exceptions
      */
     public static Object evaluate(Map<String, ? extends Object> context, String expression) {
         return evaluate(context, expression, Object.class);
@@ -83,7 +82,6 @@
      * @param expression UEL expression
      * @param expectedType The expected object Class to return
      * @return Result object
-     * @throws <code>javax.el.*</code> exceptions
      */
     public static Object evaluate(Map<String, ? extends Object> context, String expression, Class expectedType) {
         ELContext elContext = new ReadOnlyContext(context);
@@ -96,7 +94,6 @@
      * @param context Evaluation context (variables)
      * @param expression UEL expression
      * @param expectedType The expected object Class to set
-     * @throws <code>javax.el.*</code> exceptions
      */
     public static void setValue(Map<String, Object> context, String expression, Class expectedType, Object value) {
         if (Debug.verboseOn()) {
@@ -111,7 +108,6 @@
      * to null.
      * @param context Evaluation context (variables)
      * @param expression UEL expression
-     * @throws <code>javax.el.*</code> exceptions
      */
     public static void removeValue(Map<String, Object> context, String expression) {
         if (Debug.verboseOn()) {
diff --git a/framework/common/src/main/java/org/apache/ofbiz/common/preferences/PreferenceWorker.java b/framework/common/src/main/java/org/apache/ofbiz/common/preferences/PreferenceWorker.java
index 5fc4150..c104417 100644
--- a/framework/common/src/main/java/org/apache/ofbiz/common/preferences/PreferenceWorker.java
+++ b/framework/common/src/main/java/org/apache/ofbiz/common/preferences/PreferenceWorker.java
@@ -180,7 +180,7 @@
     /**
      * Checks for valid userLoginId to get preferences. Returns true if valid.
      * <p>This method applies a small rule set to determine if user preferences
-     * can be retrieved by the current user:
+     * can be retrieved by the current user:</p>
      * <ul>
      * <li>If the user isn't logged in, then the method returns true</li>
      * <li>If the user is logged in and the userPrefLoginId specified in the context Map
@@ -189,7 +189,7 @@
      * is different than the user's userLoginId, then a security permission check is performed.
      * If the user has the <a href="#ADMIN_PERMISSION">ADMIN_PERMISSION</a> permission then the
      *  method returns true.</li>
-     * </ul></p>
+     * </ul>
      *
      * @param ctx The DispatchContext that this service is operating in.
      * @param context Map containing the input arguments.
@@ -215,7 +215,7 @@
     /**
      * Checks for valid userLoginId to set preferences. Returns true if valid.
      * <p>This method applies a small rule set to determine if user preferences
-     * can be set by the current user:
+     * can be set by the current user:</p>
      * <ul>
      * <li>If the user isn't logged in, then the method returns false</li>
      * <li>If the user is logged in and the userPrefLoginId specified in the context Map
@@ -224,7 +224,7 @@
      * is different than the user's userLoginId, then a security permission check is performed.
      * If the user has the <a href="#ADMIN_PERMISSION">ADMIN_PERMISSION</a>
      * permission then the method returns true.</li>
-     * </ul></p>
+     * </ul>
      * @param ctx The DispatchContext that this service is operating in.
      * @param context Map containing the input arguments.
      * @return true if arguments are valid
diff --git a/framework/entity/src/main/java/org/apache/ofbiz/entity/Delegator.java b/framework/entity/src/main/java/org/apache/ofbiz/entity/Delegator.java
index 07b0ee9..f534b52 100644
--- a/framework/entity/src/main/java/org/apache/ofbiz/entity/Delegator.java
+++ b/framework/entity/src/main/java/org/apache/ofbiz/entity/Delegator.java
@@ -503,11 +503,10 @@
     ModelEntity getModelEntity(String entityName);
 
     /**
-     * Gets a Map of entity name & entity model pairs that are in the named
+     * Gets a Map of entity name and entity model pairs that are in the named
      * group
      *
-     * @param groupName
-     *            The name of the group
+     * @param groupName The name of the group
      * @return Map of entityName String keys and ModelEntity instance values
      */
     Map<String, ModelEntity> getModelEntityMapByGroup(String groupName) throws GenericEntityException;
@@ -739,15 +738,16 @@
     void refreshSequencer();
 
     /**
-     * Remove the Entities from the List from the persistent store. <br/>The
-     * List contains GenericEntity objects, can be either GenericPK or
-     * GenericValue. <br/>If a certain entity contains a complete primary key,
-     * the entity in the datasource corresponding to that primary key will be
-     * removed, this is like a removeByPrimary Key. <br/>On the other hand, if a
-     * certain entity is an incomplete or non primary key, if will behave like
-     * the removeByAnd method. <br/>These updates all happen in one transaction,
-     * so they will either all succeed or all fail, if the data source supports
-     * transactions.
+     * <p>Remove the Entities from the List from the persistent store.</p>
+     * <p>The List contains GenericEntity objects, can be either GenericPK or
+     * GenericValue. </p>
+     * <p>If a certain entity contains a complete primary key, the entity in 
+     * the datasource corresponding to that primary key will be removed, this 
+     * is like a removeByPrimary Key.</p>
+     * <p>On the other hand, if a certain entity is an incomplete or non 
+     * primary key, if will behave like the removeByAnd method. </p>
+     * <p>These updates all happen in one transaction, so they will either
+     * all succeed or all fail, if the data source supports transactions.</p>
      *
      * @param dummyPKs
      *            Collection of GenericEntity instances containing the entities
@@ -858,14 +858,16 @@
     int store(GenericValue value) throws GenericEntityException;
 
     /**
-     * Store the Entities from the List GenericValue instances to the persistent
-     * store. <br/>This is different than the normal store method in that the
+     * <p>Store the Entities from the List GenericValue instances to the persistent
+     * store.</p>
+     * <p>This is different than the normal store method in that the
      * store method only does an update, while the storeAll method checks to see
      * if each entity exists, then either does an insert or an update as
-     * appropriate. <br/>These updates all happen in one transaction, so they
+     * appropriate.</p>
+     * <p>These updates all happen in one transaction, so they
      * will either all succeed or all fail, if the data source supports
      * transactions. This is just like to othersToStore feature of the
-     * GenericEntity on a create or store.
+     * GenericEntity on a create or store.</p>
      *
      * @param values
      *            List of GenericValue instances containing the entities to
@@ -875,14 +877,16 @@
     int storeAll(List<GenericValue> values) throws GenericEntityException;
 
     /**
-     * Store the Entities from the List GenericValue instances to the persistent
-     * store. <br/>This is different than the normal store method in that the
+     * <p>Store the Entities from the List GenericValue instances to the persistent
+     * store.</p> 
+     * <p>This is different than the normal store method in that the
      * store method only does an update, while the storeAll method checks to see
      * if each entity exists, then either does an insert or an update as
-     * appropriate. <br/>These updates all happen in one transaction, so they
+     * appropriate.</p>
+     * <p>These updates all happen in one transaction, so they
      * will either all succeed or all fail, if the data source supports
      * transactions. This is just like to othersToStore feature of the
-     * GenericEntity on a create or store.
+     * GenericEntity on a create or store.</p>
      *
      * @param storeOptions
      *            An instance of EntityStoreOptions that specifies advanced store
@@ -896,7 +900,7 @@
     int storeAll(List<GenericValue> values, EntityStoreOptions storeOptions) throws GenericEntityException;
 
     /**
-     * Store a group of values
+     * Store a group of values.
      *
      * @param entityName
      *            The name of the Entity as defined in the entity XML file
diff --git a/framework/entity/src/main/java/org/apache/ofbiz/entity/GenericEntity.java b/framework/entity/src/main/java/org/apache/ofbiz/entity/GenericEntity.java
index 31cd65d..415a2b6 100644
--- a/framework/entity/src/main/java/org/apache/ofbiz/entity/GenericEntity.java
+++ b/framework/entity/src/main/java/org/apache/ofbiz/entity/GenericEntity.java
@@ -759,7 +759,7 @@
      *    definition as the resource name. To specify a resource name manually, use the other getResource method.
      *
      *  So, the key in the resource bundle (properties file) should be as follows:
-     *    <entity-name>.<field-name>.<pk-field-value-1>.<pk-field-value-2>...<pk-field-value-n>
+     *    &lt;entity-name&gt;.&lt;field-name&gt;.&lt;pk-field-value-1&gt;.&lt;pk-field-value-2&gt;...&lt;pk-field-value-n&gt;
      *  For example:
      *    ProductType.description.FINISHED_GOOD
      *
@@ -1419,8 +1419,8 @@
         return tempResult;
     }
 
-    /** Clones this GenericEntity, this is a shallow clone & uses the default shallow HashMap clone
-     *@return Object that is a clone of this GenericEntity
+    /** Clones this GenericEntity, this is a shallow clone and uses the default shallow HashMap clone
+     *  @return Object that is a clone of this GenericEntity
      */
     @Override
     public Object clone() {
diff --git a/framework/entity/src/main/java/org/apache/ofbiz/entity/GenericPK.java b/framework/entity/src/main/java/org/apache/ofbiz/entity/GenericPK.java
index 3ba9a58..f767803 100644
--- a/framework/entity/src/main/java/org/apache/ofbiz/entity/GenericPK.java
+++ b/framework/entity/src/main/java/org/apache/ofbiz/entity/GenericPK.java
@@ -67,8 +67,8 @@
         return false;
     }
 
-    /** Clones this GenericPK, this is a shallow clone & uses the default shallow HashMap clone
-     *@return Object that is a clone of this GenericPK
+    /** Clones this GenericPK, this is a shallow clone and uses the default shallow HashMap clone
+     *  @return Object that is a clone of this GenericPK
      */
     @Override
     public Object clone() {
diff --git a/framework/entity/src/main/java/org/apache/ofbiz/entity/GenericValue.java b/framework/entity/src/main/java/org/apache/ofbiz/entity/GenericValue.java
index 554bdb2..951d416 100644
--- a/framework/entity/src/main/java/org/apache/ofbiz/entity/GenericValue.java
+++ b/framework/entity/src/main/java/org/apache/ofbiz/entity/GenericValue.java
@@ -223,8 +223,8 @@
         return false;
     }
 
-    /** Clones this GenericValue, this is a shallow clone & uses the default shallow HashMap clone
-     *@return Object that is a clone of this GenericValue
+    /** Clones this GenericValue, this is a shallow clone and uses the default shallow HashMap clone
+     *  @return Object that is a clone of this GenericValue
      */
     @Override
     public Object clone() {
diff --git a/framework/entity/src/main/java/org/apache/ofbiz/entity/condition/EntityCondition.java b/framework/entity/src/main/java/org/apache/ofbiz/entity/condition/EntityCondition.java
index fcb2ecd..f403489 100644
--- a/framework/entity/src/main/java/org/apache/ofbiz/entity/condition/EntityCondition.java
+++ b/framework/entity/src/main/java/org/apache/ofbiz/entity/condition/EntityCondition.java
@@ -31,8 +31,8 @@
 import org.apache.ofbiz.entity.model.ModelEntity;
 
 /**
- * Represents the conditions to be used to constrain a query
- * <br/>An EntityCondition can represent various type of constraints, including:
+ * <p>Represents the conditions to be used to constrain a query.</p>
+ * <p>An EntityCondition can represent various type of constraints, including:</p>
  * <ul>
  *  <li>EntityConditionList: a list of EntityConditions, combined with the operator specified
  *  <li>EntityExpr: for simple expressions or expressions that combine EntityConditions
diff --git a/framework/entity/src/main/java/org/apache/ofbiz/entity/condition/EntityConditionBase.java b/framework/entity/src/main/java/org/apache/ofbiz/entity/condition/EntityConditionBase.java
index 504d713..f2977cb 100644
--- a/framework/entity/src/main/java/org/apache/ofbiz/entity/condition/EntityConditionBase.java
+++ b/framework/entity/src/main/java/org/apache/ofbiz/entity/condition/EntityConditionBase.java
@@ -32,8 +32,8 @@
 import org.apache.ofbiz.entity.model.ModelViewEntity.ModelAlias;
 
 /**
- * Represents the conditions to be used to constrain a query
- * <br/>An EntityCondition can represent various type of constraints, including:
+ * <p>Represents the conditions to be used to constrain a query.</p>
+ * <p>An EntityCondition can represent various type of constraints, including:</p>
  * <ul>
  *  <li>EntityConditionList: a list of EntityConditions, combined with the operator specified
  *  <li>EntityExpr: for simple expressions or expressions that combine EntityConditions
diff --git a/framework/entity/src/main/java/org/apache/ofbiz/entity/condition/EntityConditionVisitor.java b/framework/entity/src/main/java/org/apache/ofbiz/entity/condition/EntityConditionVisitor.java
index 2e0aba2..566274d 100644
--- a/framework/entity/src/main/java/org/apache/ofbiz/entity/condition/EntityConditionVisitor.java
+++ b/framework/entity/src/main/java/org/apache/ofbiz/entity/condition/EntityConditionVisitor.java
@@ -22,8 +22,8 @@
 import java.util.List;
 
 /**
- * Represents the conditions to be used to constrain a query
- * <br/>An EntityCondition can represent various type of constraints, including:
+ * <p>Represents the conditions to be used to constrain a query.</p>
+ * <p>An EntityCondition can represent various type of constraints, including:</p>
  * <ul>
  *  <li>EntityConditionList: a list of EntityConditions, combined with the operator specified
  *  <li>EntityExpr: for simple expressions or expressions that combine EntityConditions
diff --git a/framework/entity/src/main/java/org/apache/ofbiz/entity/util/EntityQuery.java b/framework/entity/src/main/java/org/apache/ofbiz/entity/util/EntityQuery.java
index d93d01a..3024e06 100644
--- a/framework/entity/src/main/java/org/apache/ofbiz/entity/util/EntityQuery.java
+++ b/framework/entity/src/main/java/org/apache/ofbiz/entity/util/EntityQuery.java
@@ -71,16 +71,14 @@
 
 
     /** Construct an EntityQuery object for use against the specified Delegator
-     * @param delegator - The delegator instance to use for the query
-     * @return Returns a new EntityQuery object
+     * @param delegator The delegator instance to use for the query
      */
     public static EntityQuery use(Delegator delegator) {
         return new EntityQuery(delegator);
     }
 
     /** Construct an EntityQuery object for use against the specified Delegator
-     * @param delegator - The delegator instance to use for the query
-     * @return Returns a new EntityQuery object
+     * @param delegator The delegator instance to use for the query
      */
     public EntityQuery(Delegator delegator) {
         this.delegator = delegator;
diff --git a/framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/JSONRequestBodyMapHandler.java b/framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/JSONRequestBodyMapHandler.java
index 8846cfe..402ead5 100644
--- a/framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/JSONRequestBodyMapHandler.java
+++ b/framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/JSONRequestBodyMapHandler.java
@@ -25,7 +25,7 @@
 import java.io.IOException;
 import java.util.Map;
 
-/** An implementation of <code>RequestBodyMapHandler</code> that can extract a <code>Map<String, Object></code> from the JSON data in the request body */
+/** An implementation of <code>RequestBodyMapHandler</code> that can extract a <code>Map&lt;String, Object&gt;</code> from the JSON data in the request body */
 public class JSONRequestBodyMapHandler implements RequestBodyMapHandler {
 
     public Map<String, Object> extractMapFromRequestBody(ServletRequest request) throws IOException {
diff --git a/framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/RequestBodyMapHandler.java b/framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/RequestBodyMapHandler.java
index 897c6b2..ccf0aba 100644
--- a/framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/RequestBodyMapHandler.java
+++ b/framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/RequestBodyMapHandler.java
@@ -24,10 +24,10 @@
 
 /** An handler that can extract a Map (typically used as a service input map) from the data in the body of a <code>ServletRequest</code>. */
 public interface RequestBodyMapHandler {
-    /** Extracts from the data in the body of the <code>ServletRequest</code> an instance of <code>Map<String, Object></code>.
+    /** Extracts from the data in the body of the <code>ServletRequest</code> an instance of <code>Map&lt;String, Object&gt;</code>.
      *
      * @param request the request with the data in its body
-     * @return an instance of <code>Map<String, Object></code> that represents the data in the request body
+     * @return an instance of <code>Map&lt;String, Object&gt;</code> that represents the data in the request body
      */
     public Map<String, Object> extractMapFromRequestBody(ServletRequest request) throws IOException;
 }
diff --git a/framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/ScriptEventHandler.java b/framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/ScriptEventHandler.java
index d3eb180..3f4d259 100644
--- a/framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/ScriptEventHandler.java
+++ b/framework/webapp/src/main/java/org/apache/ofbiz/webapp/event/ScriptEventHandler.java
@@ -39,7 +39,7 @@
 
 /**
  * Generic Script Event Handler. This event handler uses the javax.script package (JSR-223) to invoke scripts or script functions.
- * <p>The script event handler will put the following artifacts in the script engine's bindings:<br />
+ * <p>The script event handler will put the following artifacts in the script engine's bindings:</p>
  * <ul>
  *   <li><code>parameters</code> - a <code>Map</code> containing servlet context, session, request attributes and parameters</li>
  *   <li><code>request</code> - a <code>HttpServletRequest</code> instance</li>
@@ -51,7 +51,7 @@
  *   <li><code>locale</code> - a <code>Locale</code> instance</li>
  *   <li><code>timeZone</code> - a <code>TimeZone</code> instance</li>
  *   <li><code>userLogin</code> - a UserLogin <code>GenericValue</code></li>
- * </ul></p>
+ * </ul>
  * <p>If the event element includes an invoke attribute, then the matching script function/method will be called
  * with a single argument - the bindings <code>Map</code>.</p>
  */
diff --git a/specialpurpose/ldap/src/main/java/org/apache/ofbiz/ldap/commons/InterfaceOFBizAuthenticationHandler.java b/specialpurpose/ldap/src/main/java/org/apache/ofbiz/ldap/commons/InterfaceOFBizAuthenticationHandler.java
index cd3b18b..0c4f328 100644
--- a/specialpurpose/ldap/src/main/java/org/apache/ofbiz/ldap/commons/InterfaceOFBizAuthenticationHandler.java
+++ b/specialpurpose/ldap/src/main/java/org/apache/ofbiz/ldap/commons/InterfaceOFBizAuthenticationHandler.java
@@ -72,7 +72,6 @@
      * @param rootElement Element root element of ldap config file
      *
      * @return success if the user can login successfully; otherwise, error.
-     * @throws Exception
      */
     String logout(HttpServletRequest request, HttpServletResponse response, Element rootElement);
 
@@ -85,7 +84,7 @@
      * @param bindRequired boolean if true, bind; false, just search the user in LDAP
      *
      * @return result SearchResult if ldap search successfully; otherwise, null.
-     * @throws Exception
+     * @throws NamingException
      */
     SearchResult getLdapSearchResult(String username, String password, Element rootElement, boolean bindRequired) throws NamingException;
 
diff --git a/specialpurpose/pricat/src/main/java/org/apache/ofbiz/htmlreport/util/ReportEncoder.java b/specialpurpose/pricat/src/main/java/org/apache/ofbiz/htmlreport/util/ReportEncoder.java
index d82d3d0..9ba30af 100644
--- a/specialpurpose/pricat/src/main/java/org/apache/ofbiz/htmlreport/util/ReportEncoder.java
+++ b/specialpurpose/pricat/src/main/java/org/apache/ofbiz/htmlreport/util/ReportEncoder.java
@@ -426,7 +426,7 @@
      * entity representation, for example &amp; becomes &amp;#38;.<p>
      * 
      * A character <code>num</code> is replaced if<br>
-     * <code>((ch != 32) && ((ch > 122) || (ch < 48) || (ch == 60) || (ch == 62)))</code><p>
+     * <code>((ch != 32) &amp;&amp; ((ch &gt; 122) || (ch &lt; 48) || (ch == 60) || (ch == 62)))</code><p>
      * 
      * @param source the String to escape
      * 
@@ -471,7 +471,7 @@
      * entity representation, for example &amp; becomes &amp;#38;.<p>
      * 
      * A character <code>num</code> is replaced if<br>
-     * <code>(ch > 255)</code><p>
+     * <code>(ch &gt; 255)</code><p>
      * 
      * @param source the String to escape
      * 
diff --git a/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/PricatEvents.java b/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/PricatEvents.java
index 4b47931..e4303b3 100644
--- a/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/PricatEvents.java
+++ b/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/PricatEvents.java
@@ -30,7 +30,6 @@
 import javax.servlet.http.HttpServletResponse;
 
 import org.apache.commons.fileupload.servlet.ServletFileUpload;
-import org.jdom.JDOMException;
 import org.apache.ofbiz.base.location.ComponentLocationResolver;
 import org.apache.ofbiz.base.util.Debug;
 import org.apache.ofbiz.base.util.FileUtil;
@@ -61,8 +60,6 @@
      * @param request
      * @param response
      * @return
-     * @throws IOException
-     * @throws JDOMException
      */
     public static String downloadExcelTemplate(HttpServletRequest request, HttpServletResponse response) {
         String templateType = request.getParameter("templateType");
@@ -144,8 +141,6 @@
      * @param request
      * @param response
      * @return
-     * @throws IOException
-     * @throws JDOMException
      */
     public static String downloadCommentedExcel(HttpServletRequest request, HttpServletResponse response) {
         String sequenceNum = request.getParameter("sequenceNum");
diff --git a/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/PricatParseExcelHtmlReport.java b/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/PricatParseExcelHtmlReport.java
index 0d69c52..df3355b 100644
--- a/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/PricatParseExcelHtmlReport.java
+++ b/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/PricatParseExcelHtmlReport.java
@@ -37,8 +37,8 @@
     /**
      * Public constructor with report variables.<p>
      * 
-     * @param req the HttpServletRequest request
-     * @param res the HttpServletResponse response
+     * @param request the HttpServletRequest request
+     * @param response the HttpServletResponse response
      */
     public PricatParseExcelHtmlReport(HttpServletRequest request, HttpServletResponse response) {
 
diff --git a/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/sample/SamplePricatEvents.java b/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/sample/SamplePricatEvents.java
index 721ec50..0745c34 100644
--- a/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/sample/SamplePricatEvents.java
+++ b/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/sample/SamplePricatEvents.java
@@ -28,7 +28,6 @@
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
-import org.jdom.JDOMException;
 import org.apache.ofbiz.base.location.ComponentLocationResolver;
 import org.apache.ofbiz.base.util.Debug;
 import org.apache.ofbiz.base.util.UtilHttp;
@@ -52,8 +51,6 @@
      * @param request
      * @param response
      * @return
-     * @throws IOException
-     * @throws JDOMException
      */
     public static String downloadExcelTemplate(HttpServletRequest request, HttpServletResponse response) {
         String templateType = request.getParameter("templateType");
diff --git a/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/sample/SamplePricatParser.java b/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/sample/SamplePricatParser.java
index 1a8a009..4b8abd1 100644
--- a/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/sample/SamplePricatParser.java
+++ b/specialpurpose/pricat/src/main/java/org/apache/ofbiz/pricat/sample/SamplePricatParser.java
@@ -236,7 +236,6 @@
      * 
      * @param row
      * @param cellContents
-     * @param document
      * @return
      * @throws GenericTransactionException 
      */
