小编Vad*_*huk的帖子

首先,它不是任何其他问题的重复,我已经阅读了有关角度指南.不过我还有几个问题.

功能模块是最简单的 - 您有一个功能 - 将其分组到功能模块中.让我们说除了显而易见的功能外,我还有每个应用程序都有的页面:

1. 主要登陆页面(不是app.template.html,而是它在路由器插座中首先呈现的内容)
2. 错误页面,如404
3. 联系页面,关于我们页面

我可能会将所有内容移动到名为"静态"的功能模块,但我不喜欢这个名称,也不喜欢将大多数不相关的内容分组到同一个模块中,即错误页面和联系页面.那么,提到的页面的模式是什么？

现在,共享vs核心模块.我有以下几项:

1. CsrfService(听起来像我的核心)
2. 记录器(angular2-logger服务)
3. HttpModule(核心还是共享？)
4. Logged-in-guard和AuthService(我使用AuthService使用NavbarComponent/NavbarModule和LoginComponent),那些功能(登录/身份验证)还是核心/共享？

因此,主要问题是如何选择我列出的项目以及那些新项目.

我有一个简单的问题:为什么JpaRepository返回实体列表但CrudRepository返回Iterable实体？

这是故意的吗？我想这是因为CrudRepository是更通用的接口,可能有一些特定的存储库返回Iterable.

在不使用特定的JpaRepository的情况下使用CrudRepository会更加困难.

谢谢

我坚持从简单的java到spring的简单重构.Application有一个"Container"对象,它在运行时实例化其部件.让我解释一下代码:

public class Container {
    private List<RuntimeBean> runtimeBeans = new ArrayList<RuntimeBean>();

    public void load() {
        // repeated several times depending on external data/environment
        RuntimeBean beanRuntime = createRuntimeBean();
        runtimeBeans.add(beanRuntime);
    }

    public RuntimeBean createRuntimeBean() {
         // should create bean which internally can have some 
         // spring annotations or in other words
         // should be managed by spring
    }
}

基本上,在加载容器期间要求一些外部系统向他提供有关每个RuntimeBean的数量和配置的信息,然后根据给定的规范创建bean.

问题是:通常在春天做的时候

ApplicationContext context = new AnnotationConfigApplicationContext(ApplicationConfiguration.class);
Container container = (Container) context.getBean("container");

我们的对象已完全配置并注入了所有依赖项.但在我的情况下,我必须实例化一些在执行load()方法后也需要依赖注入的对象.我怎样才能做到这一点？

我正在使用基于java的配置.我已经尝试为RuntimeBeans创建一个工厂:

public class BeanRuntimeFactory {

    @Bean
    public RuntimeBean createRuntimeBean() { …

我知道有很多关于同样的问题,但我仍然需要更多的信息.我正在研究将我们的SVN repo迁移到git并试图了解什么方法(整体主干,子模块,子树等)对我们的回购最好的可能性.

以下是有关我们的项目和SVN存储库的一些信息:

• 项目是java web应用程序打包的战争.
• 它是模块化应用程序.每个模块由独立团队开发,然后打包为jar.
• 战争取决于这个罐子.

基本上我们的结构看起来像:

repo
|-application(war)
|-module1 (for example, ui stuff)
|--module1Submodule1
|--module1Submodule2
|-module2 (for example, database access stuff)
|-...

每个模块都有自己的标签和分支.

我的本地机器上的svn repo的大小包括所有分支,标签等:

• 超过250万个文件
• 超过20Gb的空间
• 有311615个修订版
• 文件主要是源代码,没有大的二进制对象

典型用例:

• 整个团队200+开发和QA
• 不同的团队承诺他们的模块/子模块.(这可能是monolith git repo的一个问题,因为git需要在推送之前提取所有更改,svn警告只有过时的更改)
• 分支模块
• 分行申请

未来的用例:

• 格里特
• 开发人员提交,提交审核,测试针对提交运行,如果是绿色,则提交被批准合并到"主"分支

问题是:

1. 我们是否可以将这样的回购视为一个大的git(我的意思是有很多帖子注意到git在大型回购中的规模很大,但是什么是'大'？)
2. 每种方法的优缺点是什么:
   • Monolith repo(只是git as svn,anti-pattern？)
   • 子模块
   • 子树(我是对的,模块中的每个更改都需要在子树repo中提交,然后将更改拉到聚合子树repo？)
   • 每个模块的单独回购
   • 任何其他..
3. 可以为每个人保留SVN的历史记录吗？
4. 我需要尽可能多的链接(我没有找到'缓慢的大型回购'的官方链接)

先感谢您!

根据维基百科:内存屏障,也称为membar,内存栅栏或栅栏指令,是一种屏障指令,它使中央处理单元(CPU)或编译器对在之前和之后发出的内存操作强制执行排序约束.障碍指导.这通常意味着在屏障之前发布的操作之前保证在屏障之前发布的操作.

通常,文章谈论类似的东西(我将使用监视器而不是membars):

class ReadWriteExample {                                          
    int A = 0;    
    int Another = 0;                                                

    //thread1 runs this method                                    
    void writer () {                                              
      lock monitor1;   //a new value will be stored            
      A = 10;          //stores 10 to memory location A        
      unlock monitor1; //a new value is ready for reader to read
      Another = 20; //@see my question  
    }                                                             

    //thread2 runs this method                                    
    void reader () {                                              
      lock monitor1;  //a new value will be read               
      assert A == 10; //loads from memory …

我有一个服务，它调用外部系统通过外部 ID 检索某种对象并将它们提交回更新。有一种更通用的方法，而不是一个接一个地检索对象：

public interface ExternalSystem {
    List<ExternalDTO> getObjects(List<String> externalIds);

    void updateObjects(List<ExternalDTO> updates);
}

我想在外部系统调用之上放置一个缓存，因为它们非常昂贵。

在服务的实现中我可以简单地添加spring注释：

@Cacheable("cache-external")
List<ExternalDTO> getObjects(List<String> externalIds) {} 

@CacheEvict(cacheNames="cache-external", allEntries=true)
void updateObjects(List<ExternalDTO> updates);

但是，如果 externalId 之间有很多交集，这样的缓存会表现得非常糟糕，即

1. Call#1 getObjects([1,2,3,4]) -> 通过 [1,2,3,4] 键缓存
2. Call#2 getObjects([1,2,3,4,5]) -> 通过 [1,2,3,4,5] 键缓存
3. Call#3 getObjects([6,7,8,9]) -> 通过 [6,7,8,9] 键缓存
4. Call#4 updateObjects( 1 ) -> 逐出所有缓存，但第三个缓存不包含 3

所以，问题是如何实现自定义策略（我认为它不能开箱即用），该策略将仅逐出那些真正应该逐出的条目，并使键以从缓存中检索相交对象的方式？

更新。我发现了两个类似的问题：

1. spring-cache-abstraction-with-multi-value-queries 弹簧缓存抽象与多值查询
2. 使用 spring-cache-on-methods-take-array-or-collection
3. spring-cacheable-methods-with-lists 弹簧可缓存方法与列表

更新2。 这与我想要的类似，只是我将为集合中的每个项目放入 String 和ExternalDTO 的缓存对。 列表到列表的元素级缓存

这是spring oauth2 教程的摘录：

如何添加本地用户数据库

许多应用程序需要在本地保存有关其用户的数据，即使将身份验证委托给外部提供者也是如此。我们这里不展示代码，但很容易分两步完成。

为您的数据库选择一个后端，并为适合您需要的自定义 User 对象设置一些存储库（例如使用 Spring Data），并且可以从外部身份验证完全或部分填充。

通过检查 /user 端点中的存储库，为每个登录的唯一用户提供一个 User 对象。如果已经存在具有当前 Principal 身份的用户，则可以对其进行更新，否则创建。

提示：在 User 对象中添加一个字段以链接到外部提供程序中的唯一标识符（不是用户名，而是外部提供程序中帐户的唯一标识符）。

因此，在用户控制器中，我们有以下代码：

@RequestMapping("/user")
public Map<String, Object> user(Principal user) {
    Map<String, Object> map = new HashMap<String, Object>();
    // for a facebook the name is facebook id, not an actual name
    map.put("name", user.getName());
    map.put("roles", AuthorityUtils.authorityListToSet(((Authentication) user)
            .getAuthorities()));
    return map;
}

Dave Syer（春季维护者）建议：

将 Principal 向下转换为 Authentication（或者可能是 OAuth2Authentication 并从中获取 userAuthentication），然后查看 details 属性。如果您的用户已使用 UserInfoTokenServices 进行身份验证，您将看到从外部提供程序的用户信息端点返回的 Map。

但对我来说这似乎不自然，原因有两个：

1. 我们为什么要在控制器调用中这样做……它闻起来很香。
2. 为什么我们还要做所有那些 instanceof 和 casts..smells。 …

我有一个相当愚蠢的问题.我们都知道流可以有许多中间操作,但只有当我们调用一些终端操作时才进行实际计算.在没有长时间呼叫终端操作的情况下传递流是否常见？

让我解释一下我的意思.请考虑使用Iterator/Iterable的以下示例

1. 使用缓冲读取器读取文件行,返回Iterator并使用next()覆盖调用 reader.readLine()
2. 在上层使用guava的Iterators.transform来说小写的一切.
3. 在上层使用另一个Iterator进行换行,可以通过昏迷从上游迭代器中拆分行并返回行中的单词元组
4. 在final类中,迭代它并写入一些OutputStream来使用迭代器.

尽管如此,我从开始到结束都进行了完全懒惰的计算.没有使用中间集合等.

如果我想对流做同样的事情,我想我应该绕过Stream对象本身.这样做很常见吗？你能与我分享一些链接吗？

我试图重构一些应用程序使用Spring DI而不是普通的java并坚持使用该问题.

基本上我有一个有几个构造函数的类:

  public MyClass() {
    this(new A());
  }

  public MyClass(A a) {
    this(a, new B()));
  }

  public MyClass(String string) {
    this(new A(string));
  }

  public MyClass(A a, B b) {
    this.a = a;
    this.c = a.getC();
    this.b = b;
    this.d = b.getD();
  }

  public MyClass(A a, B b, D d) {
    this.a = a;
    this.c = a.getC();
    this.b = b;
    this.d = d;
  }

这些构造函数在很多地方使用,其中一些在代码中,一些在测试中,等等.

现在,我将介绍基于java的Spring应用程序配置:

@Configuration
public class ApplicationConfiguration {

  @Bean
  MyClass myClass() {
    return null;
  }

}

并尝试从应用程序上下文中获取bean来重写所有位置: …

Spring security 有一个基类代表经过身份验证的 User( org.springframework.security.core.userdetails.User)：

对 UserDetailsS​​ervice 检索的核心用户信息进行建模。

开发人员可以直接使用这个类、子类化它，或者从头开始编写他们自己的 UserDetails 实现。

在互联网上的大多数示例中，例如这里人们通常为持久性创建单独的类，即com.mkyong.users.model.User在示例中。这个类没有扩展spring security的一个，所以现在我们有两个Users，一个是持久化的，一个代表系统中经过认证的User，我们所做的一切都是：

1. 通过用户名和密码检索持久性用户
2. 将字段复制到 spring 用户并返回它

所以，我的问题是，再拥有一个 User 对象有什么意义？扩展 spring security User 并坚持它不是更好吗？使用 hibernate/jpa 注释可能无法实现，因为我们显然不能在 spring 安全代码中放置注释，但是可以通过映射文件来实现。这里的另一个问题是我们不应该从服务中返回休眠实体以避免服务层之外的所有类型的休眠相关问题，所以如果我扩展 spring 用户并使其成为实体，我无论如何都需要某种 POJO从UserDetailsService. 这就是我们需要两个 User 对象的原因吗？

对文档的 Ps 参考表示赞赏