diff --git a/src/main/java/org/springframework/data/jpa/domain/JpaSort.java b/src/main/java/org/springframework/data/jpa/domain/JpaSort.java
index a67303b93..f952f696a 100644
--- a/src/main/java/org/springframework/data/jpa/domain/JpaSort.java
+++ b/src/main/java/org/springframework/data/jpa/domain/JpaSort.java
@@ -44,7 +44,9 @@ public class JpaSort extends Sort {
 	 * Creates a new {@link JpaSort} for the given attributes with the default sort direction.
 	 *
 	 * @param attributes must not be {@literal null} or empty.
+	 * @deprecated since 2.3, use {@link JpaSort#of(Attribute...)} instead.
 	 */
+	@Deprecated
 	public JpaSort(Attribute<?, ?>... attributes) {
 		this(DEFAULT_DIRECTION, attributes);
 	}
@@ -53,8 +55,10 @@ public class JpaSort extends Sort {
 	 * Creates a new {@link JpaSort} instance with the given {@link Path}s.
 	 *
 	 * @param paths must not be {@literal null} or empty.
+	 * @deprecated since 2.3, use {@link JpaSort#of(Path...))} instead.
 	 */
-	public JpaSort(JpaSort.Path<?, ?>... paths) {
+	@Deprecated
+	public JpaSort(Path<?, ?>... paths) {
 		this(DEFAULT_DIRECTION, paths);
 	}
 
@@ -63,7 +67,9 @@ public class JpaSort extends Sort {
 	 *
 	 * @param direction the sorting direction.
 	 * @param attributes must not be {@literal null} or empty.
+	 * @deprecated since 2.3, use {@link JpaSort#of(Direction, Attribute...)} instead.
 	 */
+	@Deprecated
 	public JpaSort(Direction direction, Attribute<?, ?>... attributes) {
 		this(direction, paths(attributes));
 	}
@@ -73,7 +79,9 @@ public class JpaSort extends Sort {
 	 *
 	 * @param direction the sorting direction.
 	 * @param paths must not be {@literal null} or empty.
+	 * @deprecated since 2.3, use {@link JpaSort#of(Direction, Path...)} instead.
 	 */
+	@Deprecated
 	public JpaSort(Direction direction, Path<?, ?>... paths) {
 		this(direction, Arrays.asList(paths));
 	}
@@ -90,6 +98,44 @@ public class JpaSort extends Sort {
 		super(orders);
 	}
 
+	/**
+	 * Creates a new {@link JpaSort} for the given attributes with the default sort direction.
+	 *
+	 * @param attributes must not be {@literal null} or empty.
+	 */
+	public static JpaSort of(Attribute<?, ?>... attributes) {
+		return new JpaSort(attributes);
+	}
+
+	/**
+	 * Creates a new {@link JpaSort} instance with the given {@link Path}s.
+	 *
+	 * @param paths must not be {@literal null} or empty.
+	 */
+	public static JpaSort of(JpaSort.Path<?, ?>... paths) {
+		return new JpaSort(paths);
+	}
+
+	/**
+	 * Creates a new {@link JpaSort} for the given direction and attributes.
+	 *
+	 * @param direction the sorting direction.
+	 * @param attributes must not be {@literal null} or empty.
+	 */
+	public static JpaSort of(Direction direction, Attribute<?, ?>... attributes) {
+		return new JpaSort(direction, attributes);
+	}
+
+	/**
+	 * Creates a new {@link JpaSort} for the given direction and {@link Path}s.
+	 *
+	 * @param direction the sorting direction.
+	 * @param paths must not be {@literal null} or empty.
+	 */
+	public static JpaSort of(Direction direction, Path<?, ?>... paths) {
+		return new JpaSort(direction, paths);
+	}
+
 	/**
 	 * Returns a new {@link JpaSort} with the given sorting criteria added to the current one.
 	 *
diff --git a/src/test/java/org/springframework/data/jpa/domain/JpaSortTests.java b/src/test/java/org/springframework/data/jpa/domain/JpaSortTests.java
index 011adae6e..d9e16f13d 100644
--- a/src/test/java/org/springframework/data/jpa/domain/JpaSortTests.java
+++ b/src/test/java/org/springframework/data/jpa/domain/JpaSortTests.java
@@ -26,7 +26,8 @@ import javax.persistence.metamodel.PluralAttribute;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.data.domain.Sort.Order;
-import org.springframework.data.jpa.domain.JpaSort.*;
+import org.springframework.data.jpa.domain.JpaSort.JpaOrder;
+import org.springframework.data.jpa.domain.JpaSort.Path;
 import org.springframework.data.jpa.domain.sample.Address_;
 import org.springframework.data.jpa.domain.sample.MailMessage_;
 import org.springframework.data.jpa.domain.sample.MailSender_;
@@ -58,101 +59,101 @@ public class JpaSortTests {
 
 	@Test(expected = IllegalArgumentException.class) // DATAJPA-12
 	public void rejectsNullAttribute() {
-		new JpaSort(NULL_ATTRIBUTE);
+		JpaSort.of(NULL_ATTRIBUTE);
 	}
 
 	@Test(expected = IllegalArgumentException.class) // DATAJPA-12
 	public void rejectsEmptyAttributes() {
-		new JpaSort(EMPTY_ATTRIBUTES);
+		JpaSort.of(EMPTY_ATTRIBUTES);
 	}
 
 	@Test(expected = IllegalArgumentException.class) // DATAJPA-12
 	public void rejectsNullPluralAttribute() {
-		new JpaSort(NULL_PLURAL_ATTRIBUTE);
+		JpaSort.of(NULL_PLURAL_ATTRIBUTE);
 	}
 
 	@Test(expected = IllegalArgumentException.class) // DATAJPA-12
 	public void rejectsEmptyPluralAttributes() {
-		new JpaSort(EMPTY_PLURAL_ATTRIBUTES);
+		JpaSort.of(EMPTY_PLURAL_ATTRIBUTES);
 	}
 
 	@Test // DATAJPA-12
 	public void sortBySinglePropertyWithDefaultSortDirection() {
-		assertThat(new JpaSort(path(User_.firstname))).contains(Order.asc("firstname"));
+		assertThat(JpaSort.of(path(User_.firstname))).contains(Order.asc("firstname"));
 	}
 
 	@Test // DATAJPA-12
 	public void sortByMultiplePropertiesWithDefaultSortDirection() {
-		assertThat(new JpaSort(User_.firstname, User_.lastname)).contains(Order.asc("firstname"), Order.asc("lastname"));
+		assertThat(JpaSort.of(User_.firstname, User_.lastname)).contains(Order.asc("firstname"), Order.asc("lastname"));
 	}
 
 	@Test // DATAJPA-12
 	public void sortByMultiplePropertiesWithDescSortDirection() {
 
-		assertThat(new JpaSort(DESC, User_.firstname, User_.lastname)).contains(new Order(DESC, "firstname"),
+		assertThat(JpaSort.of(DESC, User_.firstname, User_.lastname)).contains(new Order(DESC, "firstname"),
 				Order.desc("lastname"));
 	}
 
 	@Test // DATAJPA-12
 	public void combiningSortByMultipleProperties() {
 
-		assertThat(new JpaSort(User_.firstname).and(new JpaSort(User_.lastname))).contains(Order.asc("firstname"),
+		assertThat(JpaSort.of(User_.firstname).and(JpaSort.of(User_.lastname))).contains(Order.asc("firstname"),
 				Order.asc("lastname"));
 	}
 
 	@Test // DATAJPA-12
 	public void combiningSortByMultiplePropertiesWithDifferentSort() {
 
-		assertThat(new JpaSort(User_.firstname).and(new JpaSort(DESC, User_.lastname))).contains(Order.asc("firstname"),
+		assertThat(JpaSort.of(User_.firstname).and(JpaSort.of(DESC, User_.lastname))).contains(Order.asc("firstname"),
 				Order.desc("lastname"));
 	}
 
 	@Test // DATAJPA-12
 	public void combiningSortByNestedEmbeddedProperty() {
-		assertThat(new JpaSort(path(User_.address).dot(Address_.streetName))).contains(Order.asc("address.streetName"));
+		assertThat(JpaSort.of(path(User_.address).dot(Address_.streetName))).contains(Order.asc("address.streetName"));
 	}
 
 	@Test // DATAJPA-12
 	public void buildJpaSortFromJpaMetaModelSingleAttribute() {
 
-		assertThat(new JpaSort(ASC, path(User_.firstname))).contains(Order.asc("firstname"));
+		assertThat(JpaSort.of(ASC, path(User_.firstname))).contains(Order.asc("firstname"));
 	}
 
 	@Test // DATAJPA-12
 	public void buildJpaSortFromJpaMetaModelNestedAttribute() {
 
-		assertThat(new JpaSort(ASC, path(MailMessage_.mailSender).dot(MailSender_.name)))
+		assertThat(JpaSort.of(ASC, path(MailMessage_.mailSender).dot(MailSender_.name)))
 				.contains(Order.asc("mailSender.name"));
 	}
 
 	@Test // DATAJPA-702
 	public void combiningSortByMultiplePropertiesWithDifferentSortUsingSimpleAnd() {
 
-		assertThat(new JpaSort(User_.firstname).and(DESC, User_.lastname)).containsExactly(Order.asc("firstname"),
+		assertThat(JpaSort.of(User_.firstname).and(DESC, User_.lastname)).containsExactly(Order.asc("firstname"),
 				Order.desc("lastname"));
 	}
 
 	@Test // DATAJPA-702
 	public void combiningSortByMultiplePathsWithDifferentSortUsingSimpleAnd() {
 
-		assertThat(new JpaSort(User_.firstname).and(DESC, path(MailMessage_.mailSender).dot(MailSender_.name)))
+		assertThat(JpaSort.of(User_.firstname).and(DESC, path(MailMessage_.mailSender).dot(MailSender_.name)))
 				.containsExactly(Order.asc("firstname"), Order.desc("mailSender.name"));
 	}
 
 	@Test(expected = IllegalArgumentException.class) // DATAJPA-702
 	public void rejectsNullAttributesForCombiningCriterias() {
-		new JpaSort(User_.firstname).and(DESC, (Attribute<?, ?>[]) null);
+		JpaSort.of(User_.firstname).and(DESC, (Attribute<?, ?>[]) null);
 	}
 
 	@Test(expected = IllegalArgumentException.class) // DATAJPA-702
 	public void rejectsNullPathsForCombiningCriterias() {
-		new JpaSort(User_.firstname).and(DESC, (Path<?, ?>[]) null);
+		JpaSort.of(User_.firstname).and(DESC, (Path<?, ?>[]) null);
 	}
 
 	@Test // DATAJPA-702
 	public void buildsUpPathForPluralAttributesCorrectly() {
 
-		// assertThat(new JpaSort(JpaSort.path(User_.colleagues).dot(User_.roles).dot(Role_.name)), //
+		// assertThat(JpaSort.of(JpaSort.path(User_.colleagues).dot(User_.roles).dot(Role_.name)), //
 		// hasItem(new Order(ASC, "colleagues.roles.name")));
 	}
 
@@ -178,7 +179,7 @@ public class JpaSortTests {
 	@Test // DATAJPA-965
 	public void combinesSafeAndUnsafeSortCorrectly() {
 
-		// JpaSort sort = new JpaSort(path(User_.colleagues).dot(User_.roles).dot(Role_.name)).andUnsafe(DESC, "foo.bar");
+		// JpaSort sort = JpaSort.of(path(User_.colleagues).dot(User_.roles).dot(Role_.name)).andUnsafe(DESC, "foo.bar");
 		//
 		// assertThat(sort, hasItems(new Order(ASC, "colleagues.roles.name"), new Order(DESC, "foo.bar")));
 		// assertThat(sort.getOrderFor("colleagues.roles.name"), is(not(instanceOf(JpaOrder.class))));