标签: lazy-initialization

我们刚刚开始通过 Web 和辅助角色使用 Azure Redis 缓存。我们发现，在相当少量的使用情况下，创建了约 2.5K 个连接。

我们正在使用包装在连接管理器中的 StackExchange.Redis nuget 包

  public class RedisConnManager
{
    private readonly IConfiguration configuration;

    public RedisConnManager(IConfiguration configuration)
    {
        this.configuration = configuration;
    }

    public Lazy<ConnectionMultiplexer> LazyConnection
    {
        get
        {
            return new Lazy<ConnectionMultiplexer>(
                () => ConnectionMultiplexer.Connect(
                    this.configuration.SessionManagerRedisConnectionString));
        }
    }
    public ConnectionMultiplexer Connection => this.LazyConnection.Value;
}

然后使用 Ninject 作为单例将该类注入到需要的依赖类中

           kernel.Bind<RedisConnManager>().To<RedisConnManager>().InSingletonScope();

然后消费如下

 var cache = this.redisConnManager.Connection.GetDatabase();
                key = cachable.GenerateKey();
                RedisValue result = cache.StringGet(key);

我检查过 ConnectionManager 的构造函数不会被多次调用

我们应该看到这么多联系吗？

考虑有状态小部件的状态类中的以下类级别属性：

int myInt = widget.int;\n

Android Studio 通知：“无法在初始化程序中访问实例成员‘widget’。”

（我明白这个错误的含义）。

那么如果我们添加late关键字，看起来就可以了：

late int myInt = widget.int;\n

然而......这让我感到惊讶，我\xe2\x80\x99m 允许在一行中完成所有这些工作\xe2\x80\x94 我认为后期变量必须不设置/设置为空：

late int myInt;\n

...然后在onInit内部赋值。

由于我没有声明何时分配，所以我不知道何时分配。

问题是：

单行 \xe2\x80\x9clate int myInt = widget.int;\xe2\x80\x9d 是否完全等同于我自己在 initState 方法中分配它？

我的 Spring Boot 项目中有一个客户和一个客户信息实体。他们有一对多的关系。

@Data\n@Builder\n@Entity\n@NoArgsConstructor\n@AllArgsConstructor\n@Table(name = "customer")\npublic class Customer implements Serializable{\n\n    @Serial\n    private static final long serialVersionUID = 1L;\n\n    @Id\n    @GeneratedValue(strategy = GenerationType.IDENTITY)\n    private Long serialNumber;\n\n    private Long customerId;\n    private String name;\n\n\n\n    @Column(name = "session_id", length = 128)\n    private String sessionId;\n\n    @JsonManagedReference("customer-customer_info")\n    @OneToMany(targetEntity = CustomerInfo.class, mappedBy="Customer", cascade = CascadeType.ALL)\n    private List<CustomerInfo> customerInfoList;\n\n}\n\n@Data\n@Builder\n@Entity\n@NoArgsConstructor\n@AllArgsConstructor\n@Table(name = "customer_info")\npublic class CustomerInfo implements Serializable{\n\n    @Id\n    @GeneratedValue(strategy = GenerationType.IDENTITY)\n    private Long CustomerInfoId;\n\n    @ManyToOne\n    @JsonBackReference("customer-customer_info")\n    @ToString.Exclude\n    @JoinColumn(name="customer_session_id", nullable=false, referencedColumnName = "session_id")\n    private Customer customer;\n\n    private String metaKey;\n\n …

为什么斯坦福大学的课程使用所有getter的延迟初始化？

它是否正确？它有什么真正的优势吗？

一个优点(对我来说)是init方法可以变得更短,你不需要检查是否分配了变量.

我在bean标记内的spring上下文文件中定义default-lazy-init =“ true”，但是当我启动tomcat时，我看到我的bean正在实例化。这是它在日志中显示的内容-

org.springframework.beans.factory.support.DefaultListableBeanFactory（DefaultListableBeanFactory.java:555）-在org.springframework.beans.factory.support.DefaultListableBeanFactory@ac6fb1中预先实例化单例：定义bean [dataSource，我在应用程序中的其他bean。 .....

我想念什么吗？

我有两个类A和B:

class A {
    private final String someData;
    private B b;

    public String getSomeData() { return someData; }

    public B getB() {
        if (b == null) {
             b = new B(someData);
        }
        return b;
    }
}

where B是不可变的,只从一个实例计算其数据A.A具有不可变的语义,但它的内部结构是可变的(如hashCodein java.lang.String).

当我getB()从两个不同的线程调用,并且调用重叠时,我假设每个线程都有自己的实例B.但由于构造函数B只获取不可变数据,因此两个实例B应该相等.

那是对的吗？如果没有,我必须getB()同步以使其线程安全吗？

假设B实现了equals(),它比较了B的所有实例变量.对于hashCode()

任何人都可以解释在以下单例模式代码中如何进行延迟初始化？

public class Singleton 
{ 
  private static Singleton INSTANCE = null; 
  private Singleton() {} 
  public static Singleton getInstance() 
  { 
    if (INSTANCE == null) 
       INSTANCE = new Singleton(); 
    return INSTANCE; 
  } 
}

我正在使用Spring Boot和Hibernate JPA开发Web服务应用程序.我有一个分层架构,包括请求控制器层,业务逻辑(服务)层和数据访问(存储库)层.域模型/实体是:

@Entity
public class User {

    @Id
    @GeneratedValue
    private Long id;
    @OneToMany
    @JoinColumn(name = "userId")
    private List<Address> addresses;
}

@Entity
public class Address {

    @Id
    @GeneratedValue
    private Long id;
}

正如您所看到的,我有一个User实体,它具有一对多的单向关系,并且具有延迟加载策略的地址.在存储库层中,我有一个简单的用户存储库,它扩展了Spring数据JpaRepository.

public interface UserRepository extends JpaRepository<User, Long> {
}

在服务层,简单的用户提取方法没有业务逻辑.

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public User getUser(Long id) {
        return this.userRepository.findOne(id);
    }
}

在控制器简单的用户资源控制器方法

@RestController
@RequestMapping(value = "/api/v1/users")
public class UserResource {

    @Autowired
    private UserService userService;

    @RequestMapping(value = "/{userId}", method …

我有一个我正在使用的不可变结构,我正在尝试创建一个不是计算值的属性,但是它的赋值需要先前分配的属性的值.

(哇满口).

我正在努力的财产是 perimeter: Int

// Floor made out of square tiles.
struct Floor { 

  let
  size:           (x: Int, y: Int), // How many tiles in the floor
  tilePerimeter:  Int,

  // Calculate entire floor's perimeter based on tile quantity and perimeter:
  lazy let perimeter: Int = {

    let
    t4th  = self.tilePerimeter / 4,  // Tile width / length
    sx    = self.size.x * t4th,      // All X tiles' length
    sy    = self.size.y * t4th       // All Y tiles' width …

我有一个（外部）工厂类，该类以非线程安全的方式延迟初始化CXF客户端。
（如果调用得太快，则有可能两次或多次实例化客户端。）

该类具有一个受保护的方法来执行初始化。它在第一个请求上调用该方法。

我应该绕过工厂创建自己的客户吗？
通过某种方式使类通过在单个线程上发送一个请求/调用受保护的方法来初始化客户端？

还是可以安全地忽略它，因为它发生在前几个请求中？